@fctc/interface-logic 1.7.7 → 1.7.8

package/dist/services.mjs

@@ -28,660 +28,40 @@ var UriConstants = /* @__PURE__ */ ((UriConstants2) => {
   return UriConstants2;
 })(UriConstants || {});
 
-// src/store/index.ts
-import { useDispatch, useSelector } from "react-redux";
-
-// src/store/reducers/breadcrums-slice/index.ts
-import { createSlice } from "@reduxjs/toolkit";
-var initialState = {
-  breadCrumbs: []
-};
-var breadcrumbsSlice = createSlice({
-  name: "breadcrumbs",
-  initialState,
-  reducers: {
-    setBreadCrumbs: (state, action) => {
-      state.breadCrumbs = [...state.breadCrumbs, action.payload];
-    }
-  }
-});
-var { setBreadCrumbs } = breadcrumbsSlice.actions;
-var breadcrums_slice_default = breadcrumbsSlice.reducer;
+// src/configs/axios-client.ts
+import axios from "axios";
 
-// src/store/reducers/env-slice/index.ts
-import { createSlice as createSlice2 } from "@reduxjs/toolkit";
-var initialState2 = {
-  baseUrl: "",
-  companies: [],
-  user: {},
-  db: "",
-  refreshTokenEndpoint: "",
-  config: {
-    grantType: "",
-    clientId: "",
-    clientSecret: "",
-    redirectUri: ""
-  },
-  envFile: null,
-  defaultCompany: {
-    id: null,
-    logo: "",
-    secondary_color: "",
-    primary_color: ""
-  },
-  context: {
-    uid: null,
-    allowed_company_ids: [],
-    lang: "vi_VN",
-    tz: "Asia/Saigon"
-  }
-};
-var envSlice = createSlice2({
-  name: "env",
-  initialState: initialState2,
-  reducers: {
-    setEnv: (state, action) => {
-      Object.assign(state, action.payload);
-    },
-    setUid: (state, action) => {
-      state.context.uid = action.payload;
-    },
-    setAllowCompanies: (state, action) => {
-      state.context.allowed_company_ids = action.payload;
-    },
-    setCompanies: (state, action) => {
-      state.companies = action.payload;
-    },
-    setDefaultCompany: (state, action) => {
-      state.defaultCompany = action.payload;
-    },
-    setLang: (state, action) => {
-      state.context.lang = action.payload;
-    },
-    setUser: (state, action) => {
-      state.user = action.payload;
-    },
-    setConfig: (state, action) => {
-      state.config = action.payload;
-    },
-    setEnvFile: (state, action) => {
-      state.envFile = action.payload;
-    }
-  }
-});
-var {
-  setEnv,
-  setUid,
-  setLang,
-  setAllowCompanies,
-  setCompanies,
-  setDefaultCompany,
-  setUser,
-  setConfig,
-  setEnvFile
-} = envSlice.actions;
-var env_slice_default = envSlice.reducer;
+// src/utils/format.ts
+import moment from "moment";
 
-// src/store/reducers/excel-slice/index.ts
-import { createSlice as createSlice3 } from "@reduxjs/toolkit";
-var initialState3 = {
-  dataParse: null,
-  idFile: null,
-  isFileLoaded: false,
-  loadingImport: false,
-  selectedFile: null,
-  errorData: null
+// src/utils/domain/py_tokenizer.ts
+var TokenizerError = class extends Error {
 };
-var excelSlice = createSlice3({
-  name: "excel",
-  initialState: initialState3,
-  reducers: {
-    setDataParse: (state, action) => {
-      state.dataParse = action.payload;
-    },
-    setIdFile: (state, action) => {
-      state.idFile = action.payload;
-    },
-    setIsFileLoaded: (state, action) => {
-      state.isFileLoaded = action.payload;
-    },
-    setLoadingImport: (state, action) => {
-      state.loadingImport = action.payload;
-    },
-    setSelectedFile: (state, action) => {
-      state.selectedFile = action.payload;
-    },
-    setErrorData: (state, action) => {
-      state.errorData = action.payload;
-    }
-  }
-});
-var {
-  setDataParse,
-  setIdFile,
-  setIsFileLoaded,
-  setLoadingImport,
-  setSelectedFile,
-  setErrorData
-} = excelSlice.actions;
-var excel_slice_default = excelSlice.reducer;
-
-// src/store/reducers/form-slice/index.ts
-import { createSlice as createSlice4 } from "@reduxjs/toolkit";
-var initialState4 = {
-  viewDataStore: {},
-  isShowingModalDetail: false,
-  isShowModalTranslate: false,
-  formSubmitComponent: {},
-  fieldTranslation: null,
-  listSubject: {},
-  dataUser: {}
+var directMap = {
+  "\\": "\\",
+  '"': '"',
+  "'": "'",
+  a: "\x07",
+  b: "\b",
+  f: "\f",
+  n: "\n",
+  r: "\r",
+  t: "	",
+  v: "\v"
 };
-var formSlice = createSlice4({
-  name: "form",
-  initialState: initialState4,
-  reducers: {
-    setViewDataStore: (state, action) => {
-      state.viewDataStore = action.payload;
-    },
-    setIsShowingModalDetail: (state, action) => {
-      state.isShowingModalDetail = action.payload;
-    },
-    setIsShowModalTranslate: (state, action) => {
-      state.isShowModalTranslate = action.payload;
-    },
-    setFormSubmitComponent: (state, action) => {
-      state.formSubmitComponent[action.payload.key] = action.payload.component;
-    },
-    setFieldTranslate: (state, action) => {
-      state.fieldTranslation = action.payload;
-    },
-    setListSubject: (state, action) => {
-      state.listSubject = action.payload;
-    },
-    setDataUser: (state, action) => {
-      state.dataUser = action.payload;
+function decodeStringLiteral(str, unicode) {
+  const out = [];
+  let code;
+  for (let i = 0; i < str.length; ++i) {
+    if (str[i] !== "\\") {
+      out.push(str[i]);
+      continue;
     }
-  }
-});
-var {
-  setViewDataStore,
-  setIsShowingModalDetail,
-  setIsShowModalTranslate,
-  setFormSubmitComponent,
-  setFieldTranslate,
-  setListSubject,
-  setDataUser
-} = formSlice.actions;
-var form_slice_default = formSlice.reducer;
-
-// src/store/reducers/header-slice/index.ts
-import { createSlice as createSlice5 } from "@reduxjs/toolkit";
-var headerSlice = createSlice5({
-  name: "header",
-  initialState: {
-    value: { allowedCompanyIds: [] }
-  },
-  reducers: {
-    setHeader: (state, action) => {
-      state.value = { ...state.value, ...action.payload };
-    },
-    setAllowedCompanyIds: (state, action) => {
-      state.value.allowedCompanyIds = action.payload;
-    }
-  }
-});
-var { setAllowedCompanyIds, setHeader } = headerSlice.actions;
-var header_slice_default = headerSlice.reducer;
-
-// src/store/reducers/list-slice/index.ts
-import { createSlice as createSlice6 } from "@reduxjs/toolkit";
-var initialState5 = {
-  pageLimit: 10,
-  fields: {},
-  order: "",
-  selectedRowKeys: [],
-  selectedRadioKey: 0,
-  indexRowTableModal: -2,
-  isUpdateTableModal: false,
-  footerGroupTable: {},
-  transferDetail: null,
-  page: 0,
-  domainTable: []
-};
-var listSlice = createSlice6({
-  name: "list",
-  initialState: initialState5,
-  reducers: {
-    setPageLimit: (state, action) => {
-      state.pageLimit = action.payload;
-    },
-    setFields: (state, action) => {
-      state.fields = action.payload;
-    },
-    setOrder: (state, action) => {
-      state.order = action.payload;
-    },
-    setSelectedRowKeys: (state, action) => {
-      state.selectedRowKeys = action.payload;
-    },
-    setSelectedRadioKey: (state, action) => {
-      state.selectedRadioKey = action.payload;
-    },
-    setIndexRowTableModal: (state, action) => {
-      state.indexRowTableModal = action.payload;
-    },
-    setTransferDetail: (state, action) => {
-      state.transferDetail = action.payload;
-    },
-    setIsUpdateTableModal: (state, action) => {
-      state.isUpdateTableModal = action.payload;
-    },
-    setPage: (state, action) => {
-      state.page = action.payload;
-    },
-    setDomainTable: (state, action) => {
-      state.domainTable = action.payload;
-    }
-  }
-});
-var {
-  setPageLimit,
-  setFields,
-  setOrder,
-  setSelectedRowKeys,
-  setIndexRowTableModal,
-  setIsUpdateTableModal,
-  setPage,
-  setSelectedRadioKey,
-  setTransferDetail,
-  setDomainTable
-} = listSlice.actions;
-var list_slice_default = listSlice.reducer;
-
-// src/store/reducers/login-slice/index.ts
-import { createSlice as createSlice7 } from "@reduxjs/toolkit";
-var initialState6 = {
-  db: "",
-  redirectTo: "/",
-  forgotPasswordUrl: "/"
-};
-var loginSlice = createSlice7({
-  name: "login",
-  initialState: initialState6,
-  reducers: {
-    setDb: (state, action) => {
-      state.db = action.payload;
-    },
-    setRedirectTo: (state, action) => {
-      state.redirectTo = action.payload;
-    },
-    setForgotPasswordUrl: (state, action) => {
-      state.forgotPasswordUrl = action.payload;
-    }
-  }
-});
-var { setDb, setRedirectTo, setForgotPasswordUrl } = loginSlice.actions;
-var login_slice_default = loginSlice.reducer;
-
-// src/store/reducers/navbar-slice/index.ts
-import { createSlice as createSlice8 } from "@reduxjs/toolkit";
-var initialState7 = {
-  menuFocus: {},
-  menuAction: {},
-  navbarWidth: 250,
-  menuList: []
-};
-var navbarSlice = createSlice8({
-  name: "navbar",
-  initialState: initialState7,
-  reducers: {
-    setMenuFocus: (state, action) => {
-      state.menuFocus = action.payload;
-    },
-    setMenuFocusAction: (state, action) => {
-      state.menuAction = action.payload;
-    },
-    setNavbarWidth: (state, action) => {
-      state.navbarWidth = action.payload;
-    },
-    setMenuList: (state, action) => {
-      state.menuList = action.payload;
-    }
-  }
-});
-var { setMenuFocus, setMenuFocusAction, setNavbarWidth, setMenuList } = navbarSlice.actions;
-var navbar_slice_default = navbarSlice.reducer;
-
-// src/store/reducers/profile-slice/index.ts
-import { createSlice as createSlice9 } from "@reduxjs/toolkit";
-var initialState8 = {
-  profile: {}
-};
-var profileSlice = createSlice9({
-  name: "profile",
-  initialState: initialState8,
-  reducers: {
-    setProfile: (state, action) => {
-      state.profile = action.payload;
-    }
-  }
-});
-var { setProfile } = profileSlice.actions;
-var profile_slice_default = profileSlice.reducer;
-
-// src/store/reducers/search-slice/index.ts
-import { createSlice as createSlice10 } from "@reduxjs/toolkit";
-var initialState9 = {
-  groupByDomain: null,
-  searchBy: [],
-  searchString: "",
-  hoveredIndexSearchList: null,
-  selectedTags: [],
-  firstDomain: null,
-  searchMap: {},
-  filterBy: [],
-  groupBy: []
-};
-var searchSlice = createSlice10({
-  name: "search",
-  initialState: initialState9,
-  reducers: {
-    setGroupByDomain: (state, action) => {
-      state.groupByDomain = action.payload;
-    },
-    setSearchBy: (state, action) => {
-      state.searchBy = action.payload;
-    },
-    setSearchString: (state, action) => {
-      state.searchString = action.payload;
-    },
-    setHoveredIndexSearchList: (state, action) => {
-      state.hoveredIndexSearchList = action.payload;
-    },
-    setSelectedTags: (state, action) => {
-      state.selectedTags = action.payload;
-    },
-    setFirstDomain: (state, action) => {
-      state.firstDomain = action.payload;
-    },
-    setFilterBy: (state, action) => {
-      state.filterBy = action.payload;
-    },
-    setGroupBy: (state, action) => {
-      state.groupBy = action.payload;
-    },
-    setSearchMap: (state, action) => {
-      state.searchMap = action.payload;
-    },
-    updateSearchMap: (state, action) => {
-      if (!state.searchMap[action.payload.key]) {
-        state.searchMap[action.payload.key] = [];
-      }
-      state.searchMap[action.payload.key].push(action.payload.value);
-    },
-    removeKeyFromSearchMap: (state, action) => {
-      const { key, item } = action.payload;
-      const values = state.searchMap[key];
-      if (!values) return;
-      if (item) {
-        const filtered = values.filter((value) => value.name !== item.name);
-        if (filtered.length > 0) {
-          state.searchMap[key] = filtered;
-        } else {
-          delete state.searchMap[key];
-        }
-      } else {
-        delete state.searchMap[key];
-      }
-    },
-    clearSearchMap: (state) => {
-      state.searchMap = {};
-    }
-  }
-});
-var {
-  setGroupByDomain,
-  setSelectedTags,
-  setSearchString,
-  setHoveredIndexSearchList,
-  setFirstDomain,
-  setSearchBy,
-  setFilterBy,
-  setSearchMap,
-  updateSearchMap,
-  removeKeyFromSearchMap,
-  setGroupBy,
-  clearSearchMap
-} = searchSlice.actions;
-var search_slice_default = searchSlice.reducer;
-
-// src/store/store.ts
-import { configureStore } from "@reduxjs/toolkit";
-
-// node_modules/redux/dist/redux.mjs
-function formatProdErrorMessage(code) {
-  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
-}
-var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
-var ActionTypes = {
-  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
-  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
-  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
-};
-var actionTypes_default = ActionTypes;
-function isPlainObject(obj) {
-  if (typeof obj !== "object" || obj === null)
-    return false;
-  let proto = obj;
-  while (Object.getPrototypeOf(proto) !== null) {
-    proto = Object.getPrototypeOf(proto);
-  }
-  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
-}
-function miniKindOf(val) {
-  if (val === void 0)
-    return "undefined";
-  if (val === null)
-    return "null";
-  const type = typeof val;
-  switch (type) {
-    case "boolean":
-    case "string":
-    case "number":
-    case "symbol":
-    case "function": {
-      return type;
-    }
-  }
-  if (Array.isArray(val))
-    return "array";
-  if (isDate(val))
-    return "date";
-  if (isError(val))
-    return "error";
-  const constructorName = ctorName(val);
-  switch (constructorName) {
-    case "Symbol":
-    case "Promise":
-    case "WeakMap":
-    case "WeakSet":
-    case "Map":
-    case "Set":
-      return constructorName;
-  }
-  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
-}
-function ctorName(val) {
-  return typeof val.constructor === "function" ? val.constructor.name : null;
-}
-function isError(val) {
-  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
-}
-function isDate(val) {
-  if (val instanceof Date)
-    return true;
-  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
-}
-function kindOf(val) {
-  let typeOfVal = typeof val;
-  if (process.env.NODE_ENV !== "production") {
-    typeOfVal = miniKindOf(val);
-  }
-  return typeOfVal;
-}
-function warning(message) {
-  if (typeof console !== "undefined" && typeof console.error === "function") {
-    console.error(message);
-  }
-  try {
-    throw new Error(message);
-  } catch (e) {
-  }
-}
-function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
-  const reducerKeys = Object.keys(reducers);
-  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
-  if (reducerKeys.length === 0) {
-    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
-  }
-  if (!isPlainObject(inputState)) {
-    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
-  }
-  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
-  unexpectedKeys.forEach((key) => {
-    unexpectedKeyCache[key] = true;
-  });
-  if (action && action.type === actionTypes_default.REPLACE)
-    return;
-  if (unexpectedKeys.length > 0) {
-    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
-  }
-}
-function assertReducerShape(reducers) {
-  Object.keys(reducers).forEach((key) => {
-    const reducer = reducers[key];
-    const initialState10 = reducer(void 0, {
-      type: actionTypes_default.INIT
-    });
-    if (typeof initialState10 === "undefined") {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : `The slice reducer for key "${key}" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
-    }
-    if (typeof reducer(void 0, {
-      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
-    }) === "undefined") {
-      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : `The slice reducer for key "${key}" returned undefined when probed with a random type. Don't try to handle '${actionTypes_default.INIT}' or other actions in "redux/*" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.`);
-    }
-  });
-}
-function combineReducers(reducers) {
-  const reducerKeys = Object.keys(reducers);
-  const finalReducers = {};
-  for (let i = 0; i < reducerKeys.length; i++) {
-    const key = reducerKeys[i];
-    if (process.env.NODE_ENV !== "production") {
-      if (typeof reducers[key] === "undefined") {
-        warning(`No reducer provided for key "${key}"`);
-      }
-    }
-    if (typeof reducers[key] === "function") {
-      finalReducers[key] = reducers[key];
-    }
-  }
-  const finalReducerKeys = Object.keys(finalReducers);
-  let unexpectedKeyCache;
-  if (process.env.NODE_ENV !== "production") {
-    unexpectedKeyCache = {};
-  }
-  let shapeAssertionError;
-  try {
-    assertReducerShape(finalReducers);
-  } catch (e) {
-    shapeAssertionError = e;
-  }
-  return function combination(state = {}, action) {
-    if (shapeAssertionError) {
-      throw shapeAssertionError;
-    }
-    if (process.env.NODE_ENV !== "production") {
-      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
-      if (warningMessage) {
-        warning(warningMessage);
-      }
-    }
-    let hasChanged = false;
-    const nextState = {};
-    for (let i = 0; i < finalReducerKeys.length; i++) {
-      const key = finalReducerKeys[i];
-      const reducer = finalReducers[key];
-      const previousStateForKey = state[key];
-      const nextStateForKey = reducer(previousStateForKey, action);
-      if (typeof nextStateForKey === "undefined") {
-        const actionType = action && action.type;
-        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : `When called with an action of type ${actionType ? `"${String(actionType)}"` : "(unknown type)"}, the slice reducer for key "${key}" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.`);
-      }
-      nextState[key] = nextStateForKey;
-      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
-    }
-    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
-    return hasChanged ? nextState : state;
-  };
-}
-
-// src/store/store.ts
-var rootReducer = combineReducers({
-  env: env_slice_default,
-  header: header_slice_default,
-  navbar: navbar_slice_default,
-  list: list_slice_default,
-  search: search_slice_default,
-  form: form_slice_default,
-  breadcrumbs: breadcrums_slice_default,
-  login: login_slice_default,
-  excel: excel_slice_default,
-  profile: profile_slice_default
-});
-var envStore = configureStore({
-  reducer: rootReducer,
-  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
-    serializableCheck: false
-  })
-});
-
-// src/configs/axios-client.ts
-import axios from "axios";
-
-// src/utils/format.ts
-import moment from "moment";
-
-// src/utils/domain/py_tokenizer.ts
-var TokenizerError = class extends Error {
-};
-var directMap = {
-  "\\": "\\",
-  '"': '"',
-  "'": "'",
-  a: "\x07",
-  b: "\b",
-  f: "\f",
-  n: "\n",
-  r: "\r",
-  t: "	",
-  v: "\v"
-};
-function decodeStringLiteral(str, unicode) {
-  const out = [];
-  let code;
-  for (let i = 0; i < str.length; ++i) {
-    if (str[i] !== "\\") {
-      out.push(str[i]);
-      continue;
-    }
-    const escape = str[i + 1];
-    if (escape in directMap) {
-      out.push(directMap[escape]);
-      ++i;
-      continue;
+    const escape = str[i + 1];
+    if (escape in directMap) {
+      out.push(directMap[escape]);
+      ++i;
+      continue;
     }
     switch (escape) {
       case "\n":
@@ -1484,17 +864,196 @@ var PyDateTime = class _PyDateTime {
       time.second
     );
   }
-  add(timedelta) {
+  add(timedelta) {
+    const s = tmxxx(
+      this.year,
+      this.month,
+      this.day + timedelta.days,
+      this.hour,
+      this.minute,
+      this.second + timedelta.seconds,
+      this.microsecond + timedelta.microseconds
+    );
+    return new _PyDateTime(
+      s.year,
+      s.month,
+      s.day,
+      s.hour,
+      s.minute,
+      s.second,
+      s.microsecond
+    );
+  }
+  isEqual(other) {
+    if (!(other instanceof _PyDateTime)) {
+      return false;
+    }
+    return this.year === other.year && this.month === other.month && this.day === other.day && this.hour === other.hour && this.minute === other.minute && this.second === other.second && this.microsecond === other.microsecond;
+  }
+  strftime(format) {
+    return format.replace(/%([A-Za-z])/g, (m, c) => {
+      switch (c) {
+        case "Y":
+          return fmt4(this.year);
+        case "m":
+          return fmt2(this.month);
+        case "d":
+          return fmt2(this.day);
+        case "H":
+          return fmt2(this.hour);
+        case "M":
+          return fmt2(this.minute);
+        case "S":
+          return fmt2(this.second);
+        default:
+          throw new ValueError(`No known conversion for ${m}`);
+      }
+    });
+  }
+  substract(timedelta) {
+    return this.add(timedelta.negate());
+  }
+  toJSON() {
+    return this.strftime("%Y-%m-%d %H:%M:%S");
+  }
+  to_utc() {
+    const d = new Date(
+      this.year,
+      this.month - 1,
+      this.day,
+      this.hour,
+      this.minute,
+      this.second
+    );
+    const timedelta = PyTimeDelta.create({ minutes: d.getTimezoneOffset() });
+    return this.add(timedelta);
+  }
+};
+var PyTime = class _PyTime extends PyDate {
+  constructor(hour, minute, second) {
+    const now = /* @__PURE__ */ new Date();
+    const year = now.getFullYear();
+    const month = now.getMonth() + 1;
+    const day = now.getDate();
+    super(year, month, day);
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+    this.hour = hour;
+    this.minute = minute;
+    this.second = second;
+  }
+  static create(...args) {
+    const namedArgs = parseArgs(args, ["hour", "minute", "second"]);
+    const hour = namedArgs.hour || 0;
+    const minute = namedArgs.minute || 0;
+    const second = namedArgs.second || 0;
+    return new _PyTime(hour, minute, second);
+  }
+  strftime(format) {
+    return format.replace(/%([A-Za-z])/g, (m, c) => {
+      switch (c) {
+        case "Y":
+          return fmt4(this.year);
+        case "m":
+          return fmt2(this.month);
+        case "d":
+          return fmt2(this.day);
+        case "H":
+          return fmt2(this.hour);
+        case "M":
+          return fmt2(this.minute);
+        case "S":
+          return fmt2(this.second);
+        default:
+          throw new ValueError(`No known conversion for ${m}`);
+      }
+    });
+  }
+  toJSON() {
+    return this.strftime("%H:%M:%S");
+  }
+};
+var DAYS_IN_YEAR = [
+  31,
+  59,
+  90,
+  120,
+  151,
+  181,
+  212,
+  243,
+  273,
+  304,
+  334,
+  366
+];
+var TIME_PERIODS = ["hour", "minute", "second"];
+var PERIODS = ["year", "month", "day", ...TIME_PERIODS];
+var RELATIVE_KEYS = "years months weeks days hours minutes seconds microseconds leapdays".split(
+  " "
+);
+var ABSOLUTE_KEYS = "year month day hour minute second microsecond weekday nlyearday yearday".split(
+  " "
+);
+var argsSpec = ["dt1", "dt2"];
+var PyRelativeDelta = class _PyRelativeDelta {
+  static create(...args) {
+    const params = parseArgs(args, argsSpec);
+    if ("dt1" in params) {
+      throw new Error("relativedelta(dt1, dt2) is not supported for now");
+    }
+    for (const period of PERIODS) {
+      if (period in params) {
+        const val = params[period];
+        assert(val >= 0, `${period} ${val} is out of range`);
+      }
+    }
+    for (const key of RELATIVE_KEYS) {
+      params[key] = params[key] || 0;
+    }
+    for (const key of ABSOLUTE_KEYS) {
+      params[key] = key in params ? params[key] : null;
+    }
+    params.days += 7 * params.weeks;
+    let yearDay = 0;
+    if (params.nlyearday) {
+      yearDay = params.nlyearday;
+    } else if (params.yearday) {
+      yearDay = params.yearday;
+      if (yearDay > 59) {
+        params.leapDays = -1;
+      }
+    }
+    if (yearDay) {
+      for (let monthIndex = 0; monthIndex < DAYS_IN_YEAR.length; monthIndex++) {
+        if (yearDay <= DAYS_IN_YEAR[monthIndex]) {
+          params.month = monthIndex + 1;
+          if (monthIndex === 0) {
+            params.day = yearDay;
+          } else {
+            params.day = yearDay - DAYS_IN_YEAR[monthIndex - 1];
+          }
+          break;
+        }
+      }
+    }
+    return new _PyRelativeDelta(params);
+  }
+  static add(date, delta) {
+    if (!(date instanceof PyDate || date instanceof PyDateTime)) {
+      throw new NotSupportedError();
+    }
     const s = tmxxx(
-      this.year,
-      this.month,
-      this.day + timedelta.days,
-      this.hour,
-      this.minute,
-      this.second + timedelta.seconds,
-      this.microsecond + timedelta.microseconds
+      (delta.year || date.year) + delta.years,
+      (delta.month || date.month) + delta.months,
+      delta.day || date.day,
+      delta.hour || (date instanceof PyDateTime ? date.hour : 0),
+      delta.minute || (date instanceof PyDateTime ? date.minute : 0),
+      delta.second || (date instanceof PyDateTime ? date.second : 0),
+      delta.microseconds || (date instanceof PyDateTime ? date.microsecond : 0)
     );
-    return new _PyDateTime(
+    const newDateTime = new PyDateTime(
       s.year,
       s.month,
       s.day,
@@ -1503,1283 +1062,2014 @@ var PyDateTime = class _PyDateTime {
       s.second,
       s.microsecond
     );
-  }
-  isEqual(other) {
-    if (!(other instanceof _PyDateTime)) {
-      return false;
+    let leapDays = 0;
+    if (delta.leapDays && newDateTime.month > 2 && isLeap(newDateTime.year)) {
+      leapDays = delta.leapDays;
     }
-    return this.year === other.year && this.month === other.month && this.day === other.day && this.hour === other.hour && this.minute === other.minute && this.second === other.second && this.microsecond === other.microsecond;
+    const temp = newDateTime.add(
+      PyTimeDelta.create({
+        days: delta.days + leapDays,
+        hours: delta.hours,
+        minutes: delta.minutes,
+        seconds: delta.seconds,
+        microseconds: delta.microseconds
+      })
+    );
+    const hasTime = Boolean(
+      temp.hour || temp.minute || temp.second || temp.microsecond
+    );
+    const returnDate = !hasTime && date instanceof PyDate ? new PyDate(temp.year, temp.month, temp.day) : temp;
+    if (delta.weekday !== null) {
+      const wantedDow = delta.weekday + 1;
+      const _date = new Date(
+        returnDate.year,
+        returnDate.month - 1,
+        returnDate.day
+      );
+      const days = (7 - _date.getDay() + wantedDow) % 7;
+      return returnDate.add(new PyTimeDelta(days, 0, 0));
+    }
+    return returnDate;
   }
-  strftime(format) {
-    return format.replace(/%([A-Za-z])/g, (m, c) => {
-      switch (c) {
-        case "Y":
-          return fmt4(this.year);
-        case "m":
-          return fmt2(this.month);
-        case "d":
-          return fmt2(this.day);
-        case "H":
-          return fmt2(this.hour);
-        case "M":
-          return fmt2(this.minute);
-        case "S":
-          return fmt2(this.second);
-        default:
-          throw new ValueError(`No known conversion for ${m}`);
-      }
-    });
+  static substract(date, delta) {
+    return _PyRelativeDelta.add(date, delta.negate());
   }
-  substract(timedelta) {
-    return this.add(timedelta.negate());
+  constructor(params = {}, sign = 1) {
+    this.years = sign * params.years;
+    this.months = sign * params.months;
+    this.days = sign * params.days;
+    this.hours = sign * params.hours;
+    this.minutes = sign * params.minutes;
+    this.seconds = sign * params.seconds;
+    this.microseconds = sign * params.microseconds;
+    this.leapDays = params.leapDays;
+    this.year = params.year;
+    this.month = params.month;
+    this.day = params.day;
+    this.hour = params.hour;
+    this.minute = params.minute;
+    this.second = params.second;
+    this.microsecond = params.microsecond;
+    this.weekday = params.weekday;
   }
-  toJSON() {
-    return this.strftime("%Y-%m-%d %H:%M:%S");
+  years;
+  months;
+  days;
+  hours;
+  minutes;
+  seconds;
+  microseconds;
+  leapDays;
+  year;
+  month;
+  day;
+  hour;
+  minute;
+  second;
+  microsecond;
+  weekday;
+  negate() {
+    return new _PyRelativeDelta(this, -1);
   }
-  to_utc() {
-    const d = new Date(
-      this.year,
-      this.month - 1,
-      this.day,
-      this.hour,
-      this.minute,
-      this.second
-    );
-    const timedelta = PyTimeDelta.create({ minutes: d.getTimezoneOffset() });
-    return this.add(timedelta);
+  isEqual() {
+    throw new NotSupportedError();
   }
 };
-var PyTime = class _PyTime extends PyDate {
-  constructor(hour, minute, second) {
-    const now = /* @__PURE__ */ new Date();
-    const year = now.getFullYear();
-    const month = now.getMonth() + 1;
-    const day = now.getDate();
-    super(year, month, day);
-    this.hour = hour;
-    this.minute = minute;
-    this.second = second;
-    this.hour = hour;
-    this.minute = minute;
-    this.second = second;
+var TIME_DELTA_KEYS = "weeks days hours minutes seconds milliseconds microseconds".split(" ");
+function modf(x) {
+  const mod = x % 1;
+  return [mod < 0 ? mod + 1 : mod, Math.floor(x)];
+}
+var PyTimeDelta = class _PyTimeDelta {
+  constructor(days, seconds, microseconds) {
+    this.days = days;
+    this.seconds = seconds;
+    this.microseconds = microseconds;
   }
   static create(...args) {
-    const namedArgs = parseArgs(args, ["hour", "minute", "second"]);
-    const hour = namedArgs.hour || 0;
-    const minute = namedArgs.minute || 0;
-    const second = namedArgs.second || 0;
-    return new _PyTime(hour, minute, second);
+    const namedArgs = parseArgs(args, ["days", "seconds", "microseconds"]);
+    for (const key of TIME_DELTA_KEYS) {
+      namedArgs[key] = namedArgs[key] || 0;
+    }
+    let d = 0;
+    let s = 0;
+    let us = 0;
+    const days = namedArgs.days + namedArgs.weeks * 7;
+    let seconds = namedArgs.seconds + 60 * namedArgs.minutes + 3600 * namedArgs.hours;
+    let microseconds = namedArgs.microseconds + 1e3 * namedArgs.milliseconds;
+    const [dFrac, dInt] = modf(days);
+    d = dInt;
+    let daysecondsfrac = 0;
+    if (dFrac) {
+      const [dsFrac, dsInt] = modf(dFrac * 24 * 3600);
+      s = dsInt;
+      daysecondsfrac = dsFrac;
+    }
+    const [sFrac, sInt] = modf(seconds);
+    seconds = sInt;
+    const secondsfrac = sFrac + daysecondsfrac;
+    divmod(seconds, 24 * 3600, (days2, seconds2) => {
+      d += days2;
+      s += seconds2;
+    });
+    microseconds += secondsfrac * 1e6;
+    divmod(microseconds, 1e6, (seconds2, microseconds2) => {
+      divmod(seconds2, 24 * 3600, (days2, seconds3) => {
+        d += days2;
+        s += seconds3;
+        us += Math.round(microseconds2);
+      });
+    });
+    return new _PyTimeDelta(d, s, us);
   }
-  strftime(format) {
-    return format.replace(/%([A-Za-z])/g, (m, c) => {
-      switch (c) {
-        case "Y":
-          return fmt4(this.year);
-        case "m":
-          return fmt2(this.month);
-        case "d":
-          return fmt2(this.day);
-        case "H":
-          return fmt2(this.hour);
-        case "M":
-          return fmt2(this.minute);
-        case "S":
-          return fmt2(this.second);
-        default:
-          throw new ValueError(`No known conversion for ${m}`);
-      }
+  add(other) {
+    return _PyTimeDelta.create({
+      days: this.days + other.days,
+      seconds: this.seconds + other.seconds,
+      microseconds: this.microseconds + other.microseconds
     });
   }
-  toJSON() {
-    return this.strftime("%H:%M:%S");
+  divide(n) {
+    const us = (this.days * 24 * 3600 + this.seconds) * 1e6 + this.microseconds;
+    return _PyTimeDelta.create({ microseconds: Math.floor(us / n) });
+  }
+  isEqual(other) {
+    if (!(other instanceof _PyTimeDelta)) {
+      return false;
+    }
+    return this.days === other.days && this.seconds === other.seconds && this.microseconds === other.microseconds;
+  }
+  isTrue() {
+    return this.days !== 0 || this.seconds !== 0 || this.microseconds !== 0;
+  }
+  multiply(n) {
+    return _PyTimeDelta.create({
+      days: n * this.days,
+      seconds: n * this.seconds,
+      microseconds: n * this.microseconds
+    });
+  }
+  negate() {
+    return _PyTimeDelta.create({
+      days: -this.days,
+      seconds: -this.seconds,
+      microseconds: -this.microseconds
+    });
+  }
+  substract(other) {
+    return _PyTimeDelta.create({
+      days: this.days - other.days,
+      seconds: this.seconds - other.seconds,
+      microseconds: this.microseconds - other.microseconds
+    });
+  }
+  total_seconds() {
+    return this.days * 86400 + this.seconds + this.microseconds / 1e6;
+  }
+};
+
+// src/utils/domain/py_builtin.ts
+var EvaluationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EvaluationError";
   }
 };
-var DAYS_IN_YEAR = [
-  31,
-  59,
-  90,
-  120,
-  151,
-  181,
-  212,
-  243,
-  273,
-  304,
-  334,
-  366
-];
-var TIME_PERIODS = ["hour", "minute", "second"];
-var PERIODS = ["year", "month", "day", ...TIME_PERIODS];
-var RELATIVE_KEYS = "years months weeks days hours minutes seconds microseconds leapdays".split(
-  " "
-);
-var ABSOLUTE_KEYS = "year month day hour minute second microsecond weekday nlyearday yearday".split(
-  " "
-);
-var argsSpec = ["dt1", "dt2"];
-var PyRelativeDelta = class _PyRelativeDelta {
-  static create(...args) {
-    const params = parseArgs(args, argsSpec);
-    if ("dt1" in params) {
-      throw new Error("relativedelta(dt1, dt2) is not supported for now");
-    }
-    for (const period of PERIODS) {
-      if (period in params) {
-        const val = params[period];
-        assert(val >= 0, `${period} ${val} is out of range`);
-      }
-    }
-    for (const key of RELATIVE_KEYS) {
-      params[key] = params[key] || 0;
+function execOnIterable(iterable, func) {
+  if (iterable === null) {
+    throw new EvaluationError("value not iterable");
+  }
+  if (typeof iterable === "object" && !Array.isArray(iterable) && !(iterable instanceof Set)) {
+    iterable = Object.keys(iterable);
+  }
+  if (typeof iterable?.[Symbol.iterator] !== "function") {
+    throw new EvaluationError("value not iterable");
+  }
+  return func(iterable);
+}
+var BUILTINS = {
+  /**
+   * @param {any} value
+   * @returns {boolean}
+   */
+  bool(value) {
+    switch (typeof value) {
+      case "number":
+        return value !== 0;
+      case "string":
+        return value !== "";
+      case "boolean":
+        return value;
+      case "object":
+        if (value === null || value === void 0) {
+          return false;
+        }
+        if ("isTrue" in value && typeof value.isTrue === "function") {
+          return value.isTrue();
+        }
+        if (value instanceof Array) {
+          return !!value.length;
+        }
+        if (value instanceof Set) {
+          return !!value.size;
+        }
+        return Object.keys(value).length !== 0;
+      default:
+        return true;
     }
-    for (const key of ABSOLUTE_KEYS) {
-      params[key] = key in params ? params[key] : null;
+  },
+  set(iterable) {
+    if (arguments.length > 2) {
+      throw new EvaluationError(
+        `set expected at most 1 argument, got (${arguments.length - 1})`
+      );
     }
-    params.days += 7 * params.weeks;
-    let yearDay = 0;
-    if (params.nlyearday) {
-      yearDay = params.nlyearday;
-    } else if (params.yearday) {
-      yearDay = params.yearday;
-      if (yearDay > 59) {
-        params.leapDays = -1;
-      }
+    return execOnIterable(
+      iterable,
+      (iterable2) => new Set(iterable2)
+    );
+  },
+  time: {
+    strftime(format) {
+      return PyDateTime.now().strftime(format);
     }
-    if (yearDay) {
-      for (let monthIndex = 0; monthIndex < DAYS_IN_YEAR.length; monthIndex++) {
-        if (yearDay <= DAYS_IN_YEAR[monthIndex]) {
-          params.month = monthIndex + 1;
-          if (monthIndex === 0) {
-            params.day = yearDay;
-          } else {
-            params.day = yearDay - DAYS_IN_YEAR[monthIndex - 1];
-          }
-          break;
+  },
+  context_today() {
+    return PyDate.today();
+  },
+  get current_date() {
+    return this.today;
+  },
+  get today() {
+    return PyDate.today().strftime("%Y-%m-%d");
+  },
+  get now() {
+    return PyDateTime.now().strftime("%Y-%m-%d %H:%M:%S");
+  },
+  datetime: {
+    time: PyTime,
+    timedelta: PyTimeDelta,
+    datetime: PyDateTime,
+    date: PyDate
+  },
+  relativedelta: PyRelativeDelta,
+  true: true,
+  false: false
+};
+
+// src/utils/domain/py_utils.ts
+function toPyValue(value) {
+  switch (typeof value) {
+    case "string":
+      return { type: 1, value };
+    case "number":
+      return { type: 0, value };
+    case "boolean":
+      return { type: 2, value };
+    case "object":
+      if (Array.isArray(value)) {
+        return { type: 4, value: value.map(toPyValue) };
+      } else if (value === null) {
+        return {
+          type: 3
+          /* None */
+        };
+      } else if (value instanceof Date) {
+        return {
+          type: 1,
+          value: String(PyDateTime.convertDate(value))
+        };
+      } else if (value instanceof PyDate || value instanceof PyDateTime) {
+        return { type: 1, value };
+      } else {
+        const content = {};
+        for (const key in value) {
+          content[key] = toPyValue(value[key]);
         }
+        return { type: 11, value: content };
       }
-    }
-    return new _PyRelativeDelta(params);
+    default:
+      throw new Error("Invalid type");
   }
-  static add(date, delta) {
-    if (!(date instanceof PyDate || date instanceof PyDateTime)) {
-      throw new NotSupportedError();
-    }
-    const s = tmxxx(
-      (delta.year || date.year) + delta.years,
-      (delta.month || date.month) + delta.months,
-      delta.day || date.day,
-      delta.hour || (date instanceof PyDateTime ? date.hour : 0),
-      delta.minute || (date instanceof PyDateTime ? date.minute : 0),
-      delta.second || (date instanceof PyDateTime ? date.second : 0),
-      delta.microseconds || (date instanceof PyDateTime ? date.microsecond : 0)
-    );
-    const newDateTime = new PyDateTime(
-      s.year,
-      s.month,
-      s.day,
-      s.hour,
-      s.minute,
-      s.second,
-      s.microsecond
-    );
-    let leapDays = 0;
-    if (delta.leapDays && newDateTime.month > 2 && isLeap(newDateTime.year)) {
-      leapDays = delta.leapDays;
-    }
-    const temp = newDateTime.add(
-      PyTimeDelta.create({
-        days: delta.days + leapDays,
-        hours: delta.hours,
-        minutes: delta.minutes,
-        seconds: delta.seconds,
-        microseconds: delta.microseconds
-      })
-    );
-    const hasTime = Boolean(
-      temp.hour || temp.minute || temp.second || temp.microsecond
-    );
-    const returnDate = !hasTime && date instanceof PyDate ? new PyDate(temp.year, temp.month, temp.day) : temp;
-    if (delta.weekday !== null) {
-      const wantedDow = delta.weekday + 1;
-      const _date = new Date(
-        returnDate.year,
-        returnDate.month - 1,
-        returnDate.day
-      );
-      const days = (7 - _date.getDay() + wantedDow) % 7;
-      return returnDate.add(new PyTimeDelta(days, 0, 0));
+}
+function formatAST(ast, lbp = 0) {
+  switch (ast.type) {
+    case 3:
+      return "None";
+    case 1:
+      return JSON.stringify(ast.value);
+    case 0:
+      return String(ast.value);
+    case 2:
+      return ast.value ? "True" : "False";
+    case 4:
+      return `[${ast.value.map(formatAST).join(", ")}]`;
+    case 6:
+      if (ast.op === "not") {
+        return `not ${formatAST(ast.right, 50)}`;
+      }
+      return `${ast.op}${formatAST(ast.right, 130)}`;
+    case 7:
+      const abp = bp(ast.op);
+      const binaryStr = `${formatAST(ast.left, abp)} ${ast.op} ${formatAST(ast.right, abp)}`;
+      return abp < lbp ? `(${binaryStr})` : binaryStr;
+    case 11:
+      const pairs = [];
+      for (const k in ast.value) {
+        pairs.push(`"${k}": ${formatAST(ast.value[k])}`);
+      }
+      return `{${pairs.join(", ")}}`;
+    case 10:
+      return `(${ast.value.map(formatAST).join(", ")})`;
+    case 5:
+      return ast.value;
+    case 12:
+      return `${formatAST(ast.target)}[${formatAST(ast.key)}]`;
+    case 13:
+      const { ifTrue, condition, ifFalse } = ast;
+      return `${formatAST(ifTrue)} if ${formatAST(condition)} else ${formatAST(ifFalse)}`;
+    case 14:
+      const boolAbp = bp(ast.op);
+      const boolStr = `${formatAST(ast.left, boolAbp)} ${ast.op} ${formatAST(ast.right, boolAbp)}`;
+      return boolAbp < lbp ? `(${boolStr})` : boolStr;
+    case 15:
+      return `${formatAST(ast.obj, 150)}.${ast.key}`;
+    case 8:
+      const args = ast.args.map(formatAST);
+      const kwargs = [];
+      for (const kwarg in ast.kwargs) {
+        kwargs.push(`${kwarg} = ${formatAST(ast.kwargs[kwarg])}`);
+      }
+      const argStr = args.concat(kwargs).join(", ");
+      return `${formatAST(ast.fn)}(${argStr})`;
+    default:
+      throw new Error("invalid expression: " + JSON.stringify(ast));
+  }
+}
+var PY_DICT = /* @__PURE__ */ Object.create(null);
+function toPyDict(obj) {
+  return new Proxy(obj, {
+    getPrototypeOf() {
+      return PY_DICT;
     }
-    return returnDate;
+  });
+}
+
+// src/utils/domain/py_interpreter.ts
+var isTrue = BUILTINS.bool;
+function applyUnaryOp(ast, context) {
+  const value = evaluate(ast.right, context);
+  switch (ast.op) {
+    case "-":
+      if (value instanceof Object && "negate" in value) {
+        return value.negate();
+      }
+      return -value;
+    case "+":
+      return value;
+    case "not":
+      return !isTrue(value);
+    default:
+      throw new EvaluationError(`Unknown unary operator: ${ast.op}`);
   }
-  static substract(date, delta) {
-    return _PyRelativeDelta.add(date, delta.negate());
+}
+function pytypeIndex(val) {
+  switch (typeof val) {
+    case "object":
+      return val === null ? 1 : Array.isArray(val) ? 5 : 3;
+    case "number":
+      return 2;
+    case "string":
+      return 4;
+    default:
+      throw new EvaluationError(`Unknown type: ${typeof val}`);
   }
-  constructor(params = {}, sign = 1) {
-    this.years = sign * params.years;
-    this.months = sign * params.months;
-    this.days = sign * params.days;
-    this.hours = sign * params.hours;
-    this.minutes = sign * params.minutes;
-    this.seconds = sign * params.seconds;
-    this.microseconds = sign * params.microseconds;
-    this.leapDays = params.leapDays;
-    this.year = params.year;
-    this.month = params.month;
-    this.day = params.day;
-    this.hour = params.hour;
-    this.minute = params.minute;
-    this.second = params.second;
-    this.microsecond = params.microsecond;
-    this.weekday = params.weekday;
+}
+function isLess(left, right) {
+  if (typeof left === "number" && typeof right === "number") {
+    return left < right;
   }
-  years;
-  months;
-  days;
-  hours;
-  minutes;
-  seconds;
-  microseconds;
-  leapDays;
-  year;
-  month;
-  day;
-  hour;
-  minute;
-  second;
-  microsecond;
-  weekday;
-  negate() {
-    return new _PyRelativeDelta(this, -1);
+  if (typeof left === "boolean") {
+    left = left ? 1 : 0;
   }
-  isEqual() {
-    throw new NotSupportedError();
+  if (typeof right === "boolean") {
+    right = right ? 1 : 0;
   }
-};
-var TIME_DELTA_KEYS = "weeks days hours minutes seconds milliseconds microseconds".split(" ");
-function modf(x) {
-  const mod = x % 1;
-  return [mod < 0 ? mod + 1 : mod, Math.floor(x)];
-}
-var PyTimeDelta = class _PyTimeDelta {
-  constructor(days, seconds, microseconds) {
-    this.days = days;
-    this.seconds = seconds;
-    this.microseconds = microseconds;
+  const leftIndex = pytypeIndex(left);
+  const rightIndex = pytypeIndex(right);
+  if (leftIndex === rightIndex) {
+    return left < right;
   }
-  static create(...args) {
-    const namedArgs = parseArgs(args, ["days", "seconds", "microseconds"]);
-    for (const key of TIME_DELTA_KEYS) {
-      namedArgs[key] = namedArgs[key] || 0;
+  return leftIndex < rightIndex;
+}
+function isEqual(left, right) {
+  if (typeof left !== typeof right) {
+    if (typeof left === "boolean" && typeof right === "number") {
+      return right === (left ? 1 : 0);
     }
-    let d = 0;
-    let s = 0;
-    let us = 0;
-    const days = namedArgs.days + namedArgs.weeks * 7;
-    let seconds = namedArgs.seconds + 60 * namedArgs.minutes + 3600 * namedArgs.hours;
-    let microseconds = namedArgs.microseconds + 1e3 * namedArgs.milliseconds;
-    const [dFrac, dInt] = modf(days);
-    d = dInt;
-    let daysecondsfrac = 0;
-    if (dFrac) {
-      const [dsFrac, dsInt] = modf(dFrac * 24 * 3600);
-      s = dsInt;
-      daysecondsfrac = dsFrac;
+    if (typeof left === "number" && typeof right === "boolean") {
+      return left === (right ? 1 : 0);
     }
-    const [sFrac, sInt] = modf(seconds);
-    seconds = sInt;
-    const secondsfrac = sFrac + daysecondsfrac;
-    divmod(seconds, 24 * 3600, (days2, seconds2) => {
-      d += days2;
-      s += seconds2;
-    });
-    microseconds += secondsfrac * 1e6;
-    divmod(microseconds, 1e6, (seconds2, microseconds2) => {
-      divmod(seconds2, 24 * 3600, (days2, seconds3) => {
-        d += days2;
-        s += seconds3;
-        us += Math.round(microseconds2);
-      });
-    });
-    return new _PyTimeDelta(d, s, us);
+    return false;
   }
-  add(other) {
-    return _PyTimeDelta.create({
-      days: this.days + other.days,
-      seconds: this.seconds + other.seconds,
-      microseconds: this.microseconds + other.microseconds
-    });
+  if (left instanceof Object && "isEqual" in left) {
+    return left.isEqual(right);
   }
-  divide(n) {
-    const us = (this.days * 24 * 3600 + this.seconds) * 1e6 + this.microseconds;
-    return _PyTimeDelta.create({ microseconds: Math.floor(us / n) });
+  return left === right;
+}
+function isIn(left, right) {
+  if (Array.isArray(right)) {
+    return right.includes(left);
+  }
+  if (typeof right === "string" && typeof left === "string") {
+    return right.includes(left);
+  }
+  if (typeof right === "object") {
+    return left in right;
+  }
+  return false;
+}
+function applyBinaryOp(ast, context) {
+  const left = evaluate(ast.left, context);
+  const right = evaluate(ast.right, context);
+  switch (ast.op) {
+    case "+": {
+      const relativeDeltaOnLeft = left instanceof PyRelativeDelta;
+      const relativeDeltaOnRight = right instanceof PyRelativeDelta;
+      if (relativeDeltaOnLeft || relativeDeltaOnRight) {
+        const date = relativeDeltaOnLeft ? right : left;
+        const delta = relativeDeltaOnLeft ? left : right;
+        return PyRelativeDelta.add(date, delta);
+      }
+      const timeDeltaOnLeft = left instanceof PyTimeDelta;
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnLeft && timeDeltaOnRight) {
+        return left.add(right);
+      }
+      if (timeDeltaOnLeft) {
+        if (right instanceof PyDate || right instanceof PyDateTime) {
+          return right.add(left);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (timeDeltaOnRight) {
+        if (left instanceof PyDate || left instanceof PyDateTime) {
+          return left.add(right);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (left instanceof Array && right instanceof Array) {
+        return [...left, ...right];
+      }
+      return left + right;
+    }
+    case "-": {
+      const isRightDelta = right instanceof PyRelativeDelta;
+      if (isRightDelta) {
+        return PyRelativeDelta.substract(left, right);
+      }
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnRight) {
+        if (left instanceof PyTimeDelta) {
+          return left.substract(right);
+        } else if (left instanceof PyDate || left instanceof PyDateTime) {
+          return left.substract(right);
+        } else {
+          throw new NotSupportedError();
+        }
+      }
+      if (left instanceof PyDate) {
+        return left.substract(right);
+      }
+      return left - right;
+    }
+    case "*": {
+      const timeDeltaOnLeft = left instanceof PyTimeDelta;
+      const timeDeltaOnRight = right instanceof PyTimeDelta;
+      if (timeDeltaOnLeft || timeDeltaOnRight) {
+        const number = timeDeltaOnLeft ? right : left;
+        const delta = timeDeltaOnLeft ? left : right;
+        return delta.multiply(number);
+      }
+      return left * right;
+    }
+    case "/":
+      return left / right;
+    case "%":
+      return left % right;
+    case "//":
+      if (left instanceof PyTimeDelta) {
+        return left.divide(right);
+      }
+      return Math.floor(left / right);
+    case "**":
+      return left ** right;
+    case "==":
+      return isEqual(left, right);
+    case "<>":
+    case "!=":
+      return !isEqual(left, right);
+    case "<":
+      return isLess(left, right);
+    case ">":
+      return isLess(right, left);
+    case ">=":
+      return isEqual(left, right) || isLess(right, left);
+    case "<=":
+      return isEqual(left, right) || isLess(left, right);
+    case "in":
+      return isIn(left, right);
+    case "not in":
+      return !isIn(left, right);
+    default:
+      throw new EvaluationError(`Unknown binary operator: ${ast.op}`);
   }
-  isEqual(other) {
-    if (!(other instanceof _PyTimeDelta)) {
-      return false;
+}
+var DICT = {
+  get(...args) {
+    const { key, defValue } = parseArgs(args, ["key", "defValue"]);
+    const self = this;
+    if (key in self) {
+      return self[key];
+    } else if (defValue !== void 0) {
+      return defValue;
     }
-    return this.days === other.days && this.seconds === other.seconds && this.microseconds === other.microseconds;
-  }
-  isTrue() {
-    return this.days !== 0 || this.seconds !== 0 || this.microseconds !== 0;
-  }
-  multiply(n) {
-    return _PyTimeDelta.create({
-      days: n * this.days,
-      seconds: n * this.seconds,
-      microseconds: n * this.microseconds
-    });
-  }
-  negate() {
-    return _PyTimeDelta.create({
-      days: -this.days,
-      seconds: -this.seconds,
-      microseconds: -this.microseconds
-    });
-  }
-  substract(other) {
-    return _PyTimeDelta.create({
-      days: this.days - other.days,
-      seconds: this.seconds - other.seconds,
-      microseconds: this.microseconds - other.microseconds
-    });
-  }
-  total_seconds() {
-    return this.days * 86400 + this.seconds + this.microseconds / 1e6;
+    return null;
   }
 };
-
-// src/utils/domain/py_builtin.ts
-var EvaluationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "EvaluationError";
+var STRING = {
+  lower() {
+    return this.toLowerCase();
+  },
+  upper() {
+    return this.toUpperCase();
   }
 };
-function execOnIterable(iterable, func) {
-  if (iterable === null) {
-    throw new EvaluationError("value not iterable");
+function applyFunc(key, func, set, ...args) {
+  if (args.length === 1) {
+    return new Set(set);
   }
-  if (typeof iterable === "object" && !Array.isArray(iterable) && !(iterable instanceof Set)) {
-    iterable = Object.keys(iterable);
+  if (args.length > 2) {
+    throw new EvaluationError(
+      `${key}: py_js supports at most 1 argument, got (${args.length - 1})`
+    );
   }
-  if (typeof iterable?.[Symbol.iterator] !== "function") {
-    throw new EvaluationError("value not iterable");
+  return execOnIterable(args[0], func);
+}
+var SET = {
+  intersection(...args) {
+    return applyFunc(
+      "intersection",
+      (iterable) => {
+        const intersection = /* @__PURE__ */ new Set();
+        for (const i of iterable) {
+          if (this.has(i)) {
+            intersection.add(i);
+          }
+        }
+        return intersection;
+      },
+      this,
+      ...args
+    );
+  },
+  difference(...args) {
+    return applyFunc(
+      "difference",
+      (iterable) => {
+        iterable = new Set(iterable);
+        const difference = /* @__PURE__ */ new Set();
+        for (const e of this) {
+          if (!iterable.has(e)) {
+            difference.add(e);
+          }
+        }
+        return difference;
+      },
+      this,
+      ...args
+    );
+  },
+  union(...args) {
+    return applyFunc(
+      "union",
+      (iterable) => {
+        return /* @__PURE__ */ new Set([...this, ...iterable]);
+      },
+      this,
+      ...args
+    );
   }
-  return func(iterable);
+};
+function methods(_class) {
+  return Object.getOwnPropertyNames(_class.prototype).map(
+    (prop) => _class.prototype[prop]
+  );
 }
-var BUILTINS = {
-  /**
-   * @param {any} value
-   * @returns {boolean}
-   */
-  bool(value) {
-    switch (typeof value) {
-      case "number":
-        return value !== 0;
-      case "string":
-        return value !== "";
-      case "boolean":
-        return value;
-      case "object":
-        if (value === null || value === void 0) {
+var allowedFns = /* @__PURE__ */ new Set([
+  BUILTINS.time.strftime,
+  BUILTINS.set,
+  BUILTINS.bool,
+  BUILTINS.context_today,
+  BUILTINS.datetime.datetime.now,
+  BUILTINS.datetime.datetime.combine,
+  BUILTINS.datetime.date.today,
+  ...methods(BUILTINS.relativedelta),
+  ...Object.values(BUILTINS.datetime).flatMap((obj) => methods(obj)),
+  ...Object.values(SET),
+  ...Object.values(DICT),
+  ...Object.values(STRING)
+]);
+var unboundFn = Symbol("unbound function");
+function evaluate(ast, context = {}) {
+  const dicts = /* @__PURE__ */ new Set();
+  let pyContext;
+  const evalContext = Object.create(context);
+  if (!evalContext?.context) {
+    Object.defineProperty(evalContext, "context", {
+      get() {
+        if (!pyContext) {
+          pyContext = toPyDict(context);
+        }
+        return pyContext;
+      }
+    });
+  }
+  function _innerEvaluate(ast2) {
+    switch (ast2?.type) {
+      case 0:
+      // Number
+      case 1:
+        return ast2.value;
+      case 5:
+        if (ast2.value in evalContext) {
+          if (typeof evalContext[ast2.value] === "object" && evalContext[ast2.value]?.id) {
+            return evalContext[ast2.value]?.id;
+          }
+          return evalContext[ast2.value] ?? false;
+        } else if (ast2.value in BUILTINS) {
+          return BUILTINS[ast2.value];
+        } else {
           return false;
         }
-        if ("isTrue" in value && typeof value.isTrue === "function") {
-          return value.isTrue();
+      case 3:
+        return null;
+      case 2:
+        return ast2.value;
+      case 6:
+        return applyUnaryOp(ast2, evalContext);
+      case 7:
+        return applyBinaryOp(ast2, evalContext);
+      case 14:
+        const left = _evaluate(ast2.left);
+        if (ast2.op === "and") {
+          return isTrue(left) ? _evaluate(ast2.right) : left;
+        } else {
+          return isTrue(left) ? left : _evaluate(ast2.right);
         }
-        if (value instanceof Array) {
-          return !!value.length;
+      case 4:
+      // List
+      case 10:
+        return ast2.value.map(_evaluate);
+      case 11:
+        const dict = {};
+        for (const key2 in ast2.value) {
+          dict[key2] = _evaluate(ast2.value[key2]);
+        }
+        dicts.add(dict);
+        return dict;
+      case 8:
+        const fnValue = _evaluate(ast2.fn);
+        const args = ast2.args.map(_evaluate);
+        const kwargs = {};
+        for (const kwarg in ast2.kwargs) {
+          kwargs[kwarg] = _evaluate(ast2?.kwargs[kwarg]);
+        }
+        if (fnValue === PyDate || fnValue === PyDateTime || fnValue === PyTime || fnValue === PyRelativeDelta || fnValue === PyTimeDelta) {
+          return fnValue.create(...args, kwargs);
+        }
+        return fnValue(...args, kwargs);
+      case 12:
+        const dictVal = _evaluate(ast2.target);
+        const key = _evaluate(ast2.key);
+        return dictVal[key];
+      case 13:
+        if (isTrue(_evaluate(ast2.condition))) {
+          return _evaluate(ast2.ifTrue);
+        } else {
+          return _evaluate(ast2.ifFalse);
+        }
+      case 15:
+        let leftVal = _evaluate(ast2.obj);
+        let result;
+        if (dicts.has(leftVal) || Object.isPrototypeOf.call(PY_DICT, leftVal)) {
+          result = DICT[ast2.key];
+        } else if (typeof leftVal === "string") {
+          result = STRING[ast2.key];
+        } else if (leftVal instanceof Set) {
+          result = SET[ast2.key];
+        } else if (ast2.key === "get" && typeof leftVal === "object") {
+          result = DICT[ast2.key];
+          leftVal = toPyDict(leftVal);
+        } else {
+          result = leftVal[ast2.key];
         }
-        if (value instanceof Set) {
-          return !!value.size;
+        if (typeof result === "function") {
+          const bound = result.bind(leftVal);
+          bound[unboundFn] = result;
+          return bound;
         }
-        return Object.keys(value).length !== 0;
+        return result;
       default:
-        return true;
-    }
-  },
-  set(iterable) {
-    if (arguments.length > 2) {
-      throw new EvaluationError(
-        `set expected at most 1 argument, got (${arguments.length - 1})`
-      );
+        throw new EvaluationError(`AST of type ${ast2.type} cannot be evaluated`);
     }
-    return execOnIterable(
-      iterable,
-      (iterable2) => new Set(iterable2)
-    );
-  },
-  time: {
-    strftime(format) {
-      return PyDateTime.now().strftime(format);
+  }
+  function _evaluate(ast2) {
+    const val = _innerEvaluate(ast2);
+    if (typeof val === "function" && !allowedFns.has(val) && !allowedFns.has(val[unboundFn])) {
+      throw new Error("Invalid Function Call");
     }
-  },
-  context_today() {
-    return PyDate.today();
-  },
-  get current_date() {
-    return this.today;
-  },
-  get today() {
-    return PyDate.today().strftime("%Y-%m-%d");
-  },
-  get now() {
-    return PyDateTime.now().strftime("%Y-%m-%d %H:%M:%S");
-  },
-  datetime: {
-    time: PyTime,
-    timedelta: PyTimeDelta,
-    datetime: PyDateTime,
-    date: PyDate
-  },
-  relativedelta: PyRelativeDelta,
-  true: true,
-  false: false
-};
-
-// src/utils/domain/py_utils.ts
-function toPyValue(value) {
-  switch (typeof value) {
-    case "string":
-      return { type: 1, value };
-    case "number":
-      return { type: 0, value };
-    case "boolean":
-      return { type: 2, value };
-    case "object":
-      if (Array.isArray(value)) {
-        return { type: 4, value: value.map(toPyValue) };
-      } else if (value === null) {
-        return {
-          type: 3
-          /* None */
-        };
-      } else if (value instanceof Date) {
-        return {
-          type: 1,
-          value: String(PyDateTime.convertDate(value))
-        };
-      } else if (value instanceof PyDate || value instanceof PyDateTime) {
-        return { type: 1, value };
-      } else {
-        const content = {};
-        for (const key in value) {
-          content[key] = toPyValue(value[key]);
-        }
-        return { type: 11, value: content };
-      }
-    default:
-      throw new Error("Invalid type");
+    return val;
   }
+  return _evaluate(ast);
 }
-function formatAST(ast, lbp = 0) {
-  switch (ast.type) {
-    case 3:
-      return "None";
-    case 1:
-      return JSON.stringify(ast.value);
-    case 0:
-      return String(ast.value);
-    case 2:
-      return ast.value ? "True" : "False";
-    case 4:
-      return `[${ast.value.map(formatAST).join(", ")}]`;
-    case 6:
-      if (ast.op === "not") {
-        return `not ${formatAST(ast.right, 50)}`;
-      }
-      return `${ast.op}${formatAST(ast.right, 130)}`;
-    case 7:
-      const abp = bp(ast.op);
-      const binaryStr = `${formatAST(ast.left, abp)} ${ast.op} ${formatAST(ast.right, abp)}`;
-      return abp < lbp ? `(${binaryStr})` : binaryStr;
-    case 11:
-      const pairs = [];
-      for (const k in ast.value) {
-        pairs.push(`"${k}": ${formatAST(ast.value[k])}`);
-      }
-      return `{${pairs.join(", ")}}`;
-    case 10:
-      return `(${ast.value.map(formatAST).join(", ")})`;
-    case 5:
-      return ast.value;
-    case 12:
-      return `${formatAST(ast.target)}[${formatAST(ast.key)}]`;
-    case 13:
-      const { ifTrue, condition, ifFalse } = ast;
-      return `${formatAST(ifTrue)} if ${formatAST(condition)} else ${formatAST(ifFalse)}`;
-    case 14:
-      const boolAbp = bp(ast.op);
-      const boolStr = `${formatAST(ast.left, boolAbp)} ${ast.op} ${formatAST(ast.right, boolAbp)}`;
-      return boolAbp < lbp ? `(${boolStr})` : boolStr;
-    case 15:
-      return `${formatAST(ast.obj, 150)}.${ast.key}`;
-    case 8:
-      const args = ast.args.map(formatAST);
-      const kwargs = [];
-      for (const kwarg in ast.kwargs) {
-        kwargs.push(`${kwarg} = ${formatAST(ast.kwargs[kwarg])}`);
-      }
-      const argStr = args.concat(kwargs).join(", ");
-      return `${formatAST(ast.fn)}(${argStr})`;
-    default:
-      throw new Error("invalid expression: " + JSON.stringify(ast));
+
+// src/utils/domain/py.ts
+function parseExpr(expr) {
+  const tokens = tokenize(expr);
+  return parse(tokens);
+}
+
+// src/utils/domain/objects.ts
+function shallowEqual(obj1, obj2, comparisonFn = (a, b) => a === b) {
+  if (!obj1 || !obj2 || typeof obj1 !== "object" || typeof obj2 !== "object") {
+    return obj1 === obj2;
   }
+  const obj1Keys = Object.keys(obj1);
+  return obj1Keys.length === Object.keys(obj2).length && obj1Keys.every((key) => comparisonFn(obj1[key], obj2[key]));
 }
-var PY_DICT = /* @__PURE__ */ Object.create(null);
-function toPyDict(obj) {
-  return new Proxy(obj, {
-    getPrototypeOf() {
-      return PY_DICT;
-    }
-  });
+
+// src/utils/domain/arrays.ts
+var shallowEqual2 = shallowEqual;
+
+// src/utils/domain/strings.ts
+var escapeMethod = Symbol("html");
+function escapeRegExp(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-// src/utils/domain/py_interpreter.ts
-var isTrue = BUILTINS.bool;
-function applyUnaryOp(ast, context) {
-  const value = evaluate(ast.right, context);
-  switch (ast.op) {
-    case "-":
-      if (value instanceof Object && "negate" in value) {
-        return value.negate();
+// src/utils/domain/domain.ts
+var InvalidDomainError = class extends Error {
+};
+var Domain = class _Domain {
+  ast = { type: -1, value: null };
+  static TRUE;
+  static FALSE;
+  static combine(domains, operator) {
+    if (domains.length === 0) {
+      return new _Domain([]);
+    }
+    const domain1 = domains[0] instanceof _Domain ? domains[0] : new _Domain(domains[0]);
+    if (domains.length === 1) {
+      return domain1;
+    }
+    const domain2 = _Domain.combine(domains.slice(1), operator);
+    const result = new _Domain([]);
+    const astValues1 = domain1.ast.value;
+    const astValues2 = domain2.ast.value;
+    const op = operator === "AND" ? "&" : "|";
+    const combinedAST = {
+      type: 4,
+      value: astValues1.concat(astValues2)
+    };
+    result.ast = normalizeDomainAST(combinedAST, op);
+    return result;
+  }
+  static and(domains) {
+    return _Domain.combine(domains, "AND");
+  }
+  static or(domains) {
+    return _Domain.combine(domains, "OR");
+  }
+  static not(domain) {
+    const result = new _Domain(domain);
+    result.ast.value.unshift({ type: 1, value: "!" });
+    return result;
+  }
+  static removeDomainLeaves(domain, keysToRemove) {
+    function processLeaf(elements, idx, operatorCtx, newDomain2) {
+      const leaf = elements[idx];
+      if (leaf.type === 10) {
+        if (keysToRemove.includes(leaf.value[0].value)) {
+          if (operatorCtx === "&") {
+            newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
+          } else if (operatorCtx === "|") {
+            newDomain2.ast.value.push(..._Domain.FALSE.ast.value);
+          }
+        } else {
+          newDomain2.ast.value.push(leaf);
+        }
+        return 1;
+      } else if (leaf.type === 1) {
+        if (leaf.value === "|" && elements[idx + 1].type === 10 && elements[idx + 2].type === 10 && keysToRemove.includes(elements[idx + 1].value[0].value) && keysToRemove.includes(elements[idx + 2].value[0].value)) {
+          newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
+          return 3;
+        }
+        newDomain2.ast.value.push(leaf);
+        if (leaf.value === "!") {
+          return 1 + processLeaf(elements, idx + 1, "&", newDomain2);
+        }
+        const firstLeafSkip = processLeaf(
+          elements,
+          idx + 1,
+          leaf.value,
+          newDomain2
+        );
+        const secondLeafSkip = processLeaf(
+          elements,
+          idx + 1 + firstLeafSkip,
+          leaf.value,
+          newDomain2
+        );
+        return 1 + firstLeafSkip + secondLeafSkip;
       }
-      return -value;
-    case "+":
-      return value;
-    case "not":
-      return !isTrue(value);
-    default:
-      throw new EvaluationError(`Unknown unary operator: ${ast.op}`);
+      return 0;
+    }
+    const d = new _Domain(domain);
+    if (d.ast.value.length === 0) {
+      return d;
+    }
+    const newDomain = new _Domain([]);
+    processLeaf(d.ast.value, 0, "&", newDomain);
+    return newDomain;
   }
-}
-function pytypeIndex(val) {
-  switch (typeof val) {
-    case "object":
-      return val === null ? 1 : Array.isArray(val) ? 5 : 3;
-    case "number":
-      return 2;
-    case "string":
-      return 4;
-    default:
-      throw new EvaluationError(`Unknown type: ${typeof val}`);
+  constructor(descr = []) {
+    if (descr instanceof _Domain) {
+      return new _Domain(descr.toString());
+    } else {
+      let rawAST;
+      try {
+        rawAST = typeof descr === "string" ? parseExpr(descr) : toAST(descr);
+      } catch (error) {
+        throw new InvalidDomainError(
+          `Invalid domain representation: ${descr}`,
+          {
+            cause: error
+          }
+        );
+      }
+      this.ast = normalizeDomainAST(rawAST);
+    }
   }
-}
-function isLess(left, right) {
-  if (typeof left === "number" && typeof right === "number") {
-    return left < right;
+  contains(record) {
+    const expr = evaluate(this.ast, record);
+    return matchDomain(record, expr);
   }
-  if (typeof left === "boolean") {
-    left = left ? 1 : 0;
+  toString() {
+    return formatAST(this.ast);
   }
-  if (typeof right === "boolean") {
-    right = right ? 1 : 0;
+  toList(context) {
+    return evaluate(this.ast, context);
   }
-  const leftIndex = pytypeIndex(left);
-  const rightIndex = pytypeIndex(right);
-  if (leftIndex === rightIndex) {
-    return left < right;
+  toJson() {
+    try {
+      const evaluatedAsList = this.toList({});
+      const evaluatedDomain = new _Domain(evaluatedAsList);
+      if (evaluatedDomain.toString() === this.toString()) {
+        return evaluatedAsList;
+      }
+      return this.toString();
+    } catch {
+      return this.toString();
+    }
   }
-  return leftIndex < rightIndex;
-}
-function isEqual(left, right) {
-  if (typeof left !== typeof right) {
-    if (typeof left === "boolean" && typeof right === "number") {
-      return right === (left ? 1 : 0);
+};
+var TRUE_LEAF = [1, "=", 1];
+var FALSE_LEAF = [0, "=", 1];
+var TRUE_DOMAIN = new Domain([TRUE_LEAF]);
+var FALSE_DOMAIN = new Domain([FALSE_LEAF]);
+Domain.TRUE = TRUE_DOMAIN;
+Domain.FALSE = FALSE_DOMAIN;
+function toAST(domain) {
+  const elems = domain.map((elem) => {
+    switch (elem) {
+      case "!":
+      case "&":
+      case "|":
+        return { type: 1, value: elem };
+      default:
+        return {
+          type: 10,
+          value: elem.map(toPyValue)
+        };
     }
-    if (typeof left === "number" && typeof right === "boolean") {
-      return left === (right ? 1 : 0);
+  });
+  return { type: 4, value: elems };
+}
+function normalizeDomainAST(domain, op = "&") {
+  if (domain.type !== 4) {
+    if (domain.type === 10) {
+      const value = domain.value;
+      if (value.findIndex((e) => e.type === 10) === -1 || !value.every((e) => e.type === 10 || e.type === 1)) {
+        throw new InvalidDomainError("Invalid domain AST");
+      }
+    } else {
+      throw new InvalidDomainError("Invalid domain AST");
     }
-    return false;
   }
-  if (left instanceof Object && "isEqual" in left) {
-    return left.isEqual(right);
+  if (domain.value.length === 0) {
+    return domain;
   }
-  return left === right;
-}
-function isIn(left, right) {
-  if (Array.isArray(right)) {
-    return right.includes(left);
+  let expected = 1;
+  for (const child of domain.value) {
+    switch (child.type) {
+      case 1:
+        if (child.value === "&" || child.value === "|") {
+          expected++;
+        } else if (child.value !== "!") {
+          throw new InvalidDomainError("Invalid domain AST");
+        }
+        break;
+      case 4:
+      /* list */
+      case 10:
+        if (child.value.length === 3) {
+          expected--;
+          break;
+        }
+        throw new InvalidDomainError("Invalid domain AST");
+      default:
+        throw new InvalidDomainError("Invalid domain AST");
+    }
   }
-  if (typeof right === "string" && typeof left === "string") {
-    return right.includes(left);
+  const values = domain.value.slice();
+  while (expected < 0) {
+    expected++;
+    values.unshift({ type: 1, value: op });
   }
-  if (typeof right === "object") {
-    return left in right;
+  if (expected > 0) {
+    throw new InvalidDomainError(
+      `invalid domain ${formatAST(domain)} (missing ${expected} segment(s))`
+    );
   }
-  return false;
+  return { type: 4, value: values };
 }
-function applyBinaryOp(ast, context) {
-  const left = evaluate(ast.left, context);
-  const right = evaluate(ast.right, context);
-  switch (ast.op) {
-    case "+": {
-      const relativeDeltaOnLeft = left instanceof PyRelativeDelta;
-      const relativeDeltaOnRight = right instanceof PyRelativeDelta;
-      if (relativeDeltaOnLeft || relativeDeltaOnRight) {
-        const date = relativeDeltaOnLeft ? right : left;
-        const delta = relativeDeltaOnLeft ? left : right;
-        return PyRelativeDelta.add(date, delta);
-      }
-      const timeDeltaOnLeft = left instanceof PyTimeDelta;
-      const timeDeltaOnRight = right instanceof PyTimeDelta;
-      if (timeDeltaOnLeft && timeDeltaOnRight) {
-        return left.add(right);
-      }
-      if (timeDeltaOnLeft) {
-        if (right instanceof PyDate || right instanceof PyDateTime) {
-          return right.add(left);
-        } else {
-          throw new NotSupportedError();
-        }
-      }
-      if (timeDeltaOnRight) {
-        if (left instanceof PyDate || left instanceof PyDateTime) {
-          return left.add(right);
-        } else {
-          throw new NotSupportedError();
-        }
-      }
-      if (left instanceof Array && right instanceof Array) {
-        return [...left, ...right];
-      }
-      return left + right;
-    }
-    case "-": {
-      const isRightDelta = right instanceof PyRelativeDelta;
-      if (isRightDelta) {
-        return PyRelativeDelta.substract(left, right);
-      }
-      const timeDeltaOnRight = right instanceof PyTimeDelta;
-      if (timeDeltaOnRight) {
-        if (left instanceof PyTimeDelta) {
-          return left.substract(right);
-        } else if (left instanceof PyDate || left instanceof PyDateTime) {
-          return left.substract(right);
-        } else {
-          throw new NotSupportedError();
-        }
-      }
-      if (left instanceof PyDate) {
-        return left.substract(right);
-      }
-      return left - right;
-    }
-    case "*": {
-      const timeDeltaOnLeft = left instanceof PyTimeDelta;
-      const timeDeltaOnRight = right instanceof PyTimeDelta;
-      if (timeDeltaOnLeft || timeDeltaOnRight) {
-        const number = timeDeltaOnLeft ? right : left;
-        const delta = timeDeltaOnLeft ? left : right;
-        return delta.multiply(number);
-      }
-      return left * right;
+function matchCondition(record, condition) {
+  if (typeof condition === "boolean") {
+    return condition;
+  }
+  const [field, operator, value] = condition;
+  if (typeof field === "string") {
+    const names = field.split(".");
+    if (names.length >= 2) {
+      return matchCondition(record[names[0]], [
+        names.slice(1).join("."),
+        operator,
+        value
+      ]);
     }
-    case "/":
-      return left / right;
-    case "%":
-      return left % right;
-    case "//":
-      if (left instanceof PyTimeDelta) {
-        return left.divide(right);
+  }
+  let likeRegexp, ilikeRegexp;
+  if (["like", "not like", "ilike", "not ilike"].includes(operator)) {
+    likeRegexp = new RegExp(
+      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
+      "g"
+    );
+    ilikeRegexp = new RegExp(
+      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
+      "gi"
+    );
+  }
+  const fieldValue = typeof field === "number" ? field : record[field];
+  switch (operator) {
+    case "=?":
+      if ([false, null].includes(value)) {
+        return true;
       }
-      return Math.floor(left / right);
-    case "**":
-      return left ** right;
+    // eslint-disable-next-line no-fallthrough
+    case "=":
     case "==":
-      return isEqual(left, right);
-    case "<>":
+      if (Array.isArray(fieldValue) && Array.isArray(value)) {
+        return shallowEqual2(fieldValue, value);
+      }
+      return fieldValue === value;
     case "!=":
-      return !isEqual(left, right);
+    case "<>":
+      return !matchCondition(record, [field, "==", value]);
     case "<":
-      return isLess(left, right);
+      return fieldValue < value;
+    case "<=":
+      return fieldValue <= value;
     case ">":
-      return isLess(right, left);
+      return fieldValue > value;
     case ">=":
-      return isEqual(left, right) || isLess(right, left);
-    case "<=":
-      return isEqual(left, right) || isLess(left, right);
-    case "in":
-      return isIn(left, right);
-    case "not in":
-      return !isIn(left, right);
-    default:
-      throw new EvaluationError(`Unknown binary operator: ${ast.op}`);
-  }
-}
-var DICT = {
-  get(...args) {
-    const { key, defValue } = parseArgs(args, ["key", "defValue"]);
-    const self = this;
-    if (key in self) {
-      return self[key];
-    } else if (defValue !== void 0) {
-      return defValue;
+      return fieldValue >= value;
+    case "in": {
+      const val = Array.isArray(value) ? value : [value];
+      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+      return fieldVal.some((fv) => val.includes(fv));
     }
-    return null;
-  }
-};
-var STRING = {
-  lower() {
-    return this.toLowerCase();
-  },
-  upper() {
-    return this.toUpperCase();
+    case "not in": {
+      const val = Array.isArray(value) ? value : [value];
+      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
+      return !fieldVal.some((fv) => val.includes(fv));
+    }
+    case "like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(fieldValue.match(likeRegexp));
+    case "not like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(!fieldValue.match(likeRegexp));
+    case "=like":
+      if (fieldValue === false) {
+        return false;
+      }
+      return new RegExp(escapeRegExp(value).replace(/%/g, ".*")).test(
+        fieldValue
+      );
+    case "ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(fieldValue.match(ilikeRegexp));
+    case "not ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return Boolean(!fieldValue.match(ilikeRegexp));
+    case "=ilike":
+      if (fieldValue === false) {
+        return false;
+      }
+      return new RegExp(escapeRegExp(value).replace(/%/g, ".*"), "i").test(
+        fieldValue
+      );
   }
-};
-function applyFunc(key, func, set, ...args) {
-  if (args.length === 1) {
-    return new Set(set);
+  throw new InvalidDomainError("could not match domain");
+}
+function makeOperators(record) {
+  const match = matchCondition.bind(null, record);
+  return {
+    "!": (x) => !match(x),
+    "&": (a, b) => match(a) && match(b),
+    "|": (a, b) => match(a) || match(b)
+  };
+}
+function matchDomain(record, domain) {
+  if (domain.length === 0) {
+    return true;
   }
-  if (args.length > 2) {
-    throw new EvaluationError(
-      `${key}: py_js supports at most 1 argument, got (${args.length - 1})`
-    );
+  const operators = makeOperators(record);
+  const reversedDomain = Array.from(domain).reverse();
+  const condStack = [];
+  for (const item of reversedDomain) {
+    const operator = typeof item === "string" && operators[item];
+    if (operator) {
+      const operands = condStack.splice(-operator.length);
+      condStack.push(operator(...operands));
+    } else {
+      condStack.push(item);
+    }
   }
-  return execOnIterable(args[0], func);
+  return matchCondition(record, condStack.pop());
 }
-var SET = {
-  intersection(...args) {
-    return applyFunc(
-      "intersection",
-      (iterable) => {
-        const intersection = /* @__PURE__ */ new Set();
-        for (const i of iterable) {
-          if (this.has(i)) {
-            intersection.add(i);
-          }
-        }
-        return intersection;
-      },
-      this,
-      ...args
-    );
-  },
-  difference(...args) {
-    return applyFunc(
-      "difference",
-      (iterable) => {
-        iterable = new Set(iterable);
-        const difference = /* @__PURE__ */ new Set();
-        for (const e of this) {
-          if (!iterable.has(e)) {
-            difference.add(e);
-          }
-        }
-        return difference;
-      },
-      this,
-      ...args
-    );
-  },
-  union(...args) {
-    return applyFunc(
-      "union",
-      (iterable) => {
-        return /* @__PURE__ */ new Set([...this, ...iterable]);
-      },
-      this,
-      ...args
-    );
-  }
+
+// src/utils/function.ts
+import { useEffect, useState } from "react";
+var toQueryString = (params) => {
+  return Object.keys(params).map(
+    (key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key].toString())
+  ).join("&");
 };
-function methods(_class) {
-  return Object.getOwnPropertyNames(_class.prototype).map(
-    (prop) => _class.prototype[prop]
-  );
-}
-var allowedFns = /* @__PURE__ */ new Set([
-  BUILTINS.time.strftime,
-  BUILTINS.set,
-  BUILTINS.bool,
-  BUILTINS.context_today,
-  BUILTINS.datetime.datetime.now,
-  BUILTINS.datetime.datetime.combine,
-  BUILTINS.datetime.date.today,
-  ...methods(BUILTINS.relativedelta),
-  ...Object.values(BUILTINS.datetime).flatMap((obj) => methods(obj)),
-  ...Object.values(SET),
-  ...Object.values(DICT),
-  ...Object.values(STRING)
-]);
-var unboundFn = Symbol("unbound function");
-function evaluate(ast, context = {}) {
-  const dicts = /* @__PURE__ */ new Set();
-  let pyContext;
-  const evalContext = Object.create(context);
-  if (!evalContext?.context) {
-    Object.defineProperty(evalContext, "context", {
-      get() {
-        if (!pyContext) {
-          pyContext = toPyDict(context);
-        }
-        return pyContext;
+var updateTokenParamInOriginalRequest = (originalRequest, newAccessToken) => {
+  if (!originalRequest.data) return originalRequest.data;
+  if (typeof originalRequest.data === "string") {
+    try {
+      const parsedData = JSON.parse(originalRequest.data);
+      if (parsedData.with_context && typeof parsedData.with_context === "object") {
+        parsedData.with_context.token = newAccessToken;
       }
-    });
+      return JSON.stringify(parsedData);
+    } catch (e) {
+      console.warn("Failed to parse originalRequest.data", e);
+      return originalRequest.data;
+    }
   }
-  function _innerEvaluate(ast2) {
-    switch (ast2?.type) {
-      case 0:
-      // Number
-      case 1:
-        return ast2.value;
-      case 5:
-        if (ast2.value in evalContext) {
-          if (typeof evalContext[ast2.value] === "object" && evalContext[ast2.value]?.id) {
-            return evalContext[ast2.value]?.id;
-          }
-          return evalContext[ast2.value] ?? false;
-        } else if (ast2.value in BUILTINS) {
-          return BUILTINS[ast2.value];
-        } else {
-          return false;
-        }
-      case 3:
-        return null;
-      case 2:
-        return ast2.value;
-      case 6:
-        return applyUnaryOp(ast2, evalContext);
-      case 7:
-        return applyBinaryOp(ast2, evalContext);
-      case 14:
-        const left = _evaluate(ast2.left);
-        if (ast2.op === "and") {
-          return isTrue(left) ? _evaluate(ast2.right) : left;
+  if (typeof originalRequest.data === "object" && originalRequest.data.with_context) {
+    originalRequest.data.with_context.token = newAccessToken;
+  }
+  return originalRequest.data;
+};
+
+// src/utils/storage/local-storage.ts
+var localStorageUtils = () => {
+  const setToken = async (access_token) => {
+    localStorage.setItem("accessToken", access_token);
+  };
+  const setRefreshToken = async (refresh_token) => {
+    localStorage.setItem("refreshToken", refresh_token);
+  };
+  const getAccessToken = async () => {
+    return localStorage.getItem("accessToken");
+  };
+  const getRefreshToken = async () => {
+    return localStorage.getItem("refreshToken");
+  };
+  const clearToken = async () => {
+    localStorage.removeItem("accessToken");
+    localStorage.removeItem("refreshToken");
+  };
+  return {
+    setToken,
+    setRefreshToken,
+    getAccessToken,
+    getRefreshToken,
+    clearToken
+  };
+};
+
+// src/utils/storage/session-storage.ts
+var sessionStorageUtils = () => {
+  const getBrowserSession = async () => {
+    return sessionStorage.getItem("browserSession");
+  };
+  return {
+    getBrowserSession
+  };
+};
+
+// src/configs/axios-client.ts
+var axiosClient = {
+  init(config) {
+    const localStorage2 = config?.localStorageUtils ?? localStorageUtils();
+    const sessionStorage2 = config?.sessionStorageUtils ?? sessionStorageUtils();
+    const db = config?.db;
+    let isRefreshing = false;
+    let failedQueue = [];
+    const processQueue = (error, token = null) => {
+      failedQueue?.forEach((prom) => {
+        if (error) {
+          prom.reject(error);
         } else {
-          return isTrue(left) ? left : _evaluate(ast2.right);
-        }
-      case 4:
-      // List
-      case 10:
-        return ast2.value.map(_evaluate);
-      case 11:
-        const dict = {};
-        for (const key2 in ast2.value) {
-          dict[key2] = _evaluate(ast2.value[key2]);
-        }
-        dicts.add(dict);
-        return dict;
-      case 8:
-        const fnValue = _evaluate(ast2.fn);
-        const args = ast2.args.map(_evaluate);
-        const kwargs = {};
-        for (const kwarg in ast2.kwargs) {
-          kwargs[kwarg] = _evaluate(ast2?.kwargs[kwarg]);
+          prom.resolve(token);
         }
-        if (fnValue === PyDate || fnValue === PyDateTime || fnValue === PyTime || fnValue === PyRelativeDelta || fnValue === PyTimeDelta) {
-          return fnValue.create(...args, kwargs);
-        }
-        return fnValue(...args, kwargs);
-      case 12:
-        const dictVal = _evaluate(ast2.target);
-        const key = _evaluate(ast2.key);
-        return dictVal[key];
-      case 13:
-        if (isTrue(_evaluate(ast2.condition))) {
-          return _evaluate(ast2.ifTrue);
-        } else {
-          return _evaluate(ast2.ifFalse);
+      });
+      failedQueue = [];
+    };
+    const instance = axios.create({
+      adapter: axios.defaults.adapter,
+      baseURL: config.baseUrl,
+      timeout: 5e4,
+      paramsSerializer: (params) => new URLSearchParams(params).toString()
+    });
+    instance.interceptors.request.use(
+      async (config2) => {
+        const useRefreshToken = config2.useRefreshToken;
+        const token = useRefreshToken ? await localStorage2.getRefreshToken() : await localStorage2.getAccessToken();
+        if (token) {
+          config2.headers["Authorization"] = "Bearer " + token;
         }
-      case 15:
-        let leftVal = _evaluate(ast2.obj);
-        let result;
-        if (dicts.has(leftVal) || Object.isPrototypeOf.call(PY_DICT, leftVal)) {
-          result = DICT[ast2.key];
-        } else if (typeof leftVal === "string") {
-          result = STRING[ast2.key];
-        } else if (leftVal instanceof Set) {
-          result = SET[ast2.key];
-        } else if (ast2.key === "get" && typeof leftVal === "object") {
-          result = DICT[ast2.key];
-          leftVal = toPyDict(leftVal);
-        } else {
-          result = leftVal[ast2.key];
+        return config2;
+      },
+      (error) => {
+        Promise.reject(error);
+      }
+    );
+    instance.interceptors.response.use(
+      (response) => {
+        return handleResponse(response);
+      },
+      async (error) => {
+        const handleError3 = async (error2) => {
+          if (!error2.response) {
+            return error2;
+          }
+          const { data } = error2.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((token) => {
+              originalRequest.headers["Authorization"] = "Bearer " + token;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                token
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, value]) => !!value)
+            );
+            return new Promise(function(resolve) {
+              axios.post(
+                `${config.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
+                }
+              ).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_BAD_REQUEST") || err?.error_code === "ERR_2FA_006") {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  if (error_code === "AUTHEN_FAIL") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
         }
-        if (typeof result === "function") {
-          const bound = result.bind(leftVal);
-          bound[unboundFn] = result;
-          return bound;
+        return Promise.reject(await handleError3(error));
+      }
+    );
+    const handleResponse = (res) => {
+      if (res && res.data) {
+        return res.data;
+      }
+      return res;
+    };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
+    const clearAuthToken = async () => {
+      await localStorage2.clearToken();
+      if (typeof window !== "undefined") {
+        window.location.href = `/login`;
+      }
+    };
+    function formatUrl(url, db2) {
+      return url + (db2 ? "?db=" + db2 : "");
+    }
+    const responseBody = (response) => response;
+    const requests = {
+      get: (url, headers) => instance.get(formatUrl(url, db), headers).then(responseBody),
+      post: (url, body, headers) => instance.post(formatUrl(url, db), body, headers).then(responseBody),
+      post_excel: (url, body, headers) => instance.post(formatUrl(url, db), body, {
+        responseType: "arraybuffer",
+        headers: {
+          "Content-Type": typeof window !== "undefined" ? "application/json" : "application/javascript",
+          Accept: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
         }
-        return result;
-      default:
-        throw new EvaluationError(`AST of type ${ast2.type} cannot be evaluated`);
+      }).then(responseBody),
+      put: (url, body, headers) => instance.put(formatUrl(url, db), body, headers).then(responseBody),
+      patch: (url, body) => instance.patch(formatUrl(url, db), body).then(responseBody),
+      delete: (url, body) => instance.delete(formatUrl(url, db), body).then(responseBody)
+    };
+    return requests;
+  }
+};
+
+// src/store/index.ts
+import { useDispatch, useSelector } from "react-redux";
+
+// src/store/reducers/breadcrums-slice/index.ts
+import { createSlice } from "@reduxjs/toolkit";
+var initialState = {
+  breadCrumbs: []
+};
+var breadcrumbsSlice = createSlice({
+  name: "breadcrumbs",
+  initialState,
+  reducers: {
+    setBreadCrumbs: (state, action) => {
+      state.breadCrumbs = [...state.breadCrumbs, action.payload];
+    }
+  }
+});
+var { setBreadCrumbs } = breadcrumbsSlice.actions;
+var breadcrums_slice_default = breadcrumbsSlice.reducer;
+
+// src/store/reducers/env-slice/index.ts
+import { createSlice as createSlice2 } from "@reduxjs/toolkit";
+var initialState2 = {
+  baseUrl: "",
+  requests: null,
+  companies: [],
+  user: {},
+  config: null,
+  envFile: null,
+  defaultCompany: {
+    id: null,
+    logo: "",
+    secondary_color: "",
+    primary_color: ""
+  },
+  context: {
+    uid: null,
+    allowed_company_ids: [],
+    lang: "vi_VN",
+    tz: "Asia/Saigon"
+  }
+};
+var envSlice = createSlice2({
+  name: "env",
+  initialState: initialState2,
+  reducers: {
+    setEnv: (state, action) => {
+      Object.assign(state, action.payload);
+    },
+    setUid: (state, action) => {
+      state.context.uid = action.payload;
+    },
+    setAllowCompanies: (state, action) => {
+      state.context.allowed_company_ids = action.payload;
+    },
+    setCompanies: (state, action) => {
+      state.companies = action.payload;
+    },
+    setDefaultCompany: (state, action) => {
+      state.defaultCompany = action.payload;
+    },
+    setLang: (state, action) => {
+      state.context.lang = action.payload;
+    },
+    setUser: (state, action) => {
+      state.user = action.payload;
+    },
+    setConfig: (state, action) => {
+      state.config = action.payload;
+    },
+    setEnvFile: (state, action) => {
+      state.envFile = action.payload;
+    }
+  }
+});
+var {
+  setEnv,
+  setUid,
+  setLang,
+  setAllowCompanies,
+  setCompanies,
+  setDefaultCompany,
+  setUser,
+  setConfig,
+  setEnvFile
+} = envSlice.actions;
+var env_slice_default = envSlice.reducer;
+
+// src/store/reducers/excel-slice/index.ts
+import { createSlice as createSlice3 } from "@reduxjs/toolkit";
+var initialState3 = {
+  dataParse: null,
+  idFile: null,
+  isFileLoaded: false,
+  loadingImport: false,
+  selectedFile: null,
+  errorData: null
+};
+var excelSlice = createSlice3({
+  name: "excel",
+  initialState: initialState3,
+  reducers: {
+    setDataParse: (state, action) => {
+      state.dataParse = action.payload;
+    },
+    setIdFile: (state, action) => {
+      state.idFile = action.payload;
+    },
+    setIsFileLoaded: (state, action) => {
+      state.isFileLoaded = action.payload;
+    },
+    setLoadingImport: (state, action) => {
+      state.loadingImport = action.payload;
+    },
+    setSelectedFile: (state, action) => {
+      state.selectedFile = action.payload;
+    },
+    setErrorData: (state, action) => {
+      state.errorData = action.payload;
+    }
+  }
+});
+var {
+  setDataParse,
+  setIdFile,
+  setIsFileLoaded,
+  setLoadingImport,
+  setSelectedFile,
+  setErrorData
+} = excelSlice.actions;
+var excel_slice_default = excelSlice.reducer;
+
+// src/store/reducers/form-slice/index.ts
+import { createSlice as createSlice4 } from "@reduxjs/toolkit";
+var initialState4 = {
+  viewDataStore: {},
+  isShowingModalDetail: false,
+  isShowModalTranslate: false,
+  formSubmitComponent: {},
+  fieldTranslation: null,
+  listSubject: {},
+  dataUser: {}
+};
+var formSlice = createSlice4({
+  name: "form",
+  initialState: initialState4,
+  reducers: {
+    setViewDataStore: (state, action) => {
+      state.viewDataStore = action.payload;
+    },
+    setIsShowingModalDetail: (state, action) => {
+      state.isShowingModalDetail = action.payload;
+    },
+    setIsShowModalTranslate: (state, action) => {
+      state.isShowModalTranslate = action.payload;
+    },
+    setFormSubmitComponent: (state, action) => {
+      state.formSubmitComponent[action.payload.key] = action.payload.component;
+    },
+    setFieldTranslate: (state, action) => {
+      state.fieldTranslation = action.payload;
+    },
+    setListSubject: (state, action) => {
+      state.listSubject = action.payload;
+    },
+    setDataUser: (state, action) => {
+      state.dataUser = action.payload;
     }
   }
-  function _evaluate(ast2) {
-    const val = _innerEvaluate(ast2);
-    if (typeof val === "function" && !allowedFns.has(val) && !allowedFns.has(val[unboundFn])) {
-      throw new Error("Invalid Function Call");
+});
+var {
+  setViewDataStore,
+  setIsShowingModalDetail,
+  setIsShowModalTranslate,
+  setFormSubmitComponent,
+  setFieldTranslate,
+  setListSubject,
+  setDataUser
+} = formSlice.actions;
+var form_slice_default = formSlice.reducer;
+
+// src/store/reducers/header-slice/index.ts
+import { createSlice as createSlice5 } from "@reduxjs/toolkit";
+var headerSlice = createSlice5({
+  name: "header",
+  initialState: {
+    value: { allowedCompanyIds: [] }
+  },
+  reducers: {
+    setHeader: (state, action) => {
+      state.value = { ...state.value, ...action.payload };
+    },
+    setAllowedCompanyIds: (state, action) => {
+      state.value.allowedCompanyIds = action.payload;
     }
-    return val;
   }
-  return _evaluate(ast);
-}
+});
+var { setAllowedCompanyIds, setHeader } = headerSlice.actions;
+var header_slice_default = headerSlice.reducer;
 
-// src/utils/domain/py.ts
-function parseExpr(expr) {
-  const tokens = tokenize(expr);
-  return parse(tokens);
-}
+// src/store/reducers/list-slice/index.ts
+import { createSlice as createSlice6 } from "@reduxjs/toolkit";
+var initialState5 = {
+  pageLimit: 10,
+  fields: {},
+  order: "",
+  selectedRowKeys: [],
+  selectedRadioKey: 0,
+  indexRowTableModal: -2,
+  isUpdateTableModal: false,
+  footerGroupTable: {},
+  transferDetail: null,
+  page: 0,
+  domainTable: []
+};
+var listSlice = createSlice6({
+  name: "list",
+  initialState: initialState5,
+  reducers: {
+    setPageLimit: (state, action) => {
+      state.pageLimit = action.payload;
+    },
+    setFields: (state, action) => {
+      state.fields = action.payload;
+    },
+    setOrder: (state, action) => {
+      state.order = action.payload;
+    },
+    setSelectedRowKeys: (state, action) => {
+      state.selectedRowKeys = action.payload;
+    },
+    setSelectedRadioKey: (state, action) => {
+      state.selectedRadioKey = action.payload;
+    },
+    setIndexRowTableModal: (state, action) => {
+      state.indexRowTableModal = action.payload;
+    },
+    setTransferDetail: (state, action) => {
+      state.transferDetail = action.payload;
+    },
+    setIsUpdateTableModal: (state, action) => {
+      state.isUpdateTableModal = action.payload;
+    },
+    setPage: (state, action) => {
+      state.page = action.payload;
+    },
+    setDomainTable: (state, action) => {
+      state.domainTable = action.payload;
+    }
+  }
+});
+var {
+  setPageLimit,
+  setFields,
+  setOrder,
+  setSelectedRowKeys,
+  setIndexRowTableModal,
+  setIsUpdateTableModal,
+  setPage,
+  setSelectedRadioKey,
+  setTransferDetail,
+  setDomainTable
+} = listSlice.actions;
+var list_slice_default = listSlice.reducer;
 
-// src/utils/domain/objects.ts
-function shallowEqual(obj1, obj2, comparisonFn = (a, b) => a === b) {
-  if (!obj1 || !obj2 || typeof obj1 !== "object" || typeof obj2 !== "object") {
-    return obj1 === obj2;
+// src/store/reducers/login-slice/index.ts
+import { createSlice as createSlice7 } from "@reduxjs/toolkit";
+var initialState6 = {
+  db: "",
+  redirectTo: "/",
+  forgotPasswordUrl: "/"
+};
+var loginSlice = createSlice7({
+  name: "login",
+  initialState: initialState6,
+  reducers: {
+    setDb: (state, action) => {
+      state.db = action.payload;
+    },
+    setRedirectTo: (state, action) => {
+      state.redirectTo = action.payload;
+    },
+    setForgotPasswordUrl: (state, action) => {
+      state.forgotPasswordUrl = action.payload;
+    }
   }
-  const obj1Keys = Object.keys(obj1);
-  return obj1Keys.length === Object.keys(obj2).length && obj1Keys.every((key) => comparisonFn(obj1[key], obj2[key]));
-}
+});
+var { setDb, setRedirectTo, setForgotPasswordUrl } = loginSlice.actions;
+var login_slice_default = loginSlice.reducer;
+
+// src/store/reducers/navbar-slice/index.ts
+import { createSlice as createSlice8 } from "@reduxjs/toolkit";
+var initialState7 = {
+  menuFocus: {},
+  menuAction: {},
+  navbarWidth: 250,
+  menuList: []
+};
+var navbarSlice = createSlice8({
+  name: "navbar",
+  initialState: initialState7,
+  reducers: {
+    setMenuFocus: (state, action) => {
+      state.menuFocus = action.payload;
+    },
+    setMenuFocusAction: (state, action) => {
+      state.menuAction = action.payload;
+    },
+    setNavbarWidth: (state, action) => {
+      state.navbarWidth = action.payload;
+    },
+    setMenuList: (state, action) => {
+      state.menuList = action.payload;
+    }
+  }
+});
+var { setMenuFocus, setMenuFocusAction, setNavbarWidth, setMenuList } = navbarSlice.actions;
+var navbar_slice_default = navbarSlice.reducer;
+
+// src/store/reducers/profile-slice/index.ts
+import { createSlice as createSlice9 } from "@reduxjs/toolkit";
+var initialState8 = {
+  profile: {}
+};
+var profileSlice = createSlice9({
+  name: "profile",
+  initialState: initialState8,
+  reducers: {
+    setProfile: (state, action) => {
+      state.profile = action.payload;
+    }
+  }
+});
+var { setProfile } = profileSlice.actions;
+var profile_slice_default = profileSlice.reducer;
+
+// src/store/reducers/search-slice/index.ts
+import { createSlice as createSlice10 } from "@reduxjs/toolkit";
+var initialState9 = {
+  groupByDomain: null,
+  searchBy: [],
+  searchString: "",
+  hoveredIndexSearchList: null,
+  selectedTags: [],
+  firstDomain: null,
+  searchMap: {},
+  filterBy: [],
+  groupBy: []
+};
+var searchSlice = createSlice10({
+  name: "search",
+  initialState: initialState9,
+  reducers: {
+    setGroupByDomain: (state, action) => {
+      state.groupByDomain = action.payload;
+    },
+    setSearchBy: (state, action) => {
+      state.searchBy = action.payload;
+    },
+    setSearchString: (state, action) => {
+      state.searchString = action.payload;
+    },
+    setHoveredIndexSearchList: (state, action) => {
+      state.hoveredIndexSearchList = action.payload;
+    },
+    setSelectedTags: (state, action) => {
+      state.selectedTags = action.payload;
+    },
+    setFirstDomain: (state, action) => {
+      state.firstDomain = action.payload;
+    },
+    setFilterBy: (state, action) => {
+      state.filterBy = action.payload;
+    },
+    setGroupBy: (state, action) => {
+      state.groupBy = action.payload;
+    },
+    setSearchMap: (state, action) => {
+      state.searchMap = action.payload;
+    },
+    updateSearchMap: (state, action) => {
+      if (!state.searchMap[action.payload.key]) {
+        state.searchMap[action.payload.key] = [];
+      }
+      state.searchMap[action.payload.key].push(action.payload.value);
+    },
+    removeKeyFromSearchMap: (state, action) => {
+      const { key, item } = action.payload;
+      const values = state.searchMap[key];
+      if (!values) return;
+      if (item) {
+        const filtered = values.filter((value) => value.name !== item.name);
+        if (filtered.length > 0) {
+          state.searchMap[key] = filtered;
+        } else {
+          delete state.searchMap[key];
+        }
+      } else {
+        delete state.searchMap[key];
+      }
+    },
+    clearSearchMap: (state) => {
+      state.searchMap = {};
+    }
+  }
+});
+var {
+  setGroupByDomain,
+  setSelectedTags,
+  setSearchString,
+  setHoveredIndexSearchList,
+  setFirstDomain,
+  setSearchBy,
+  setFilterBy,
+  setSearchMap,
+  updateSearchMap,
+  removeKeyFromSearchMap,
+  setGroupBy,
+  clearSearchMap
+} = searchSlice.actions;
+var search_slice_default = searchSlice.reducer;
 
-// src/utils/domain/arrays.ts
-var shallowEqual2 = shallowEqual;
+// src/store/store.ts
+import { configureStore } from "@reduxjs/toolkit";
 
-// src/utils/domain/strings.ts
-var escapeMethod = Symbol("html");
-function escapeRegExp(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+// node_modules/redux/dist/redux.mjs
+function formatProdErrorMessage(code) {
+  return `Minified Redux error #${code}; visit https://redux.js.org/Errors?code=${code} for the full message or use the non-minified dev environment for full errors. `;
 }
-
-// src/utils/domain/domain.ts
-var InvalidDomainError = class extends Error {
+var randomString = () => Math.random().toString(36).substring(7).split("").join(".");
+var ActionTypes = {
+  INIT: `@@redux/INIT${/* @__PURE__ */ randomString()}`,
+  REPLACE: `@@redux/REPLACE${/* @__PURE__ */ randomString()}`,
+  PROBE_UNKNOWN_ACTION: () => `@@redux/PROBE_UNKNOWN_ACTION${randomString()}`
 };
-var Domain = class _Domain {
-  ast = { type: -1, value: null };
-  static TRUE;
-  static FALSE;
-  static combine(domains, operator) {
-    if (domains.length === 0) {
-      return new _Domain([]);
-    }
-    const domain1 = domains[0] instanceof _Domain ? domains[0] : new _Domain(domains[0]);
-    if (domains.length === 1) {
-      return domain1;
-    }
-    const domain2 = _Domain.combine(domains.slice(1), operator);
-    const result = new _Domain([]);
-    const astValues1 = domain1.ast.value;
-    const astValues2 = domain2.ast.value;
-    const op = operator === "AND" ? "&" : "|";
-    const combinedAST = {
-      type: 4,
-      value: astValues1.concat(astValues2)
-    };
-    result.ast = normalizeDomainAST(combinedAST, op);
-    return result;
-  }
-  static and(domains) {
-    return _Domain.combine(domains, "AND");
+var actionTypes_default = ActionTypes;
+function isPlainObject(obj) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  let proto = obj;
+  while (Object.getPrototypeOf(proto) !== null) {
+    proto = Object.getPrototypeOf(proto);
   }
-  static or(domains) {
-    return _Domain.combine(domains, "OR");
+  return Object.getPrototypeOf(obj) === proto || Object.getPrototypeOf(obj) === null;
+}
+function miniKindOf(val) {
+  if (val === void 0)
+    return "undefined";
+  if (val === null)
+    return "null";
+  const type = typeof val;
+  switch (type) {
+    case "boolean":
+    case "string":
+    case "number":
+    case "symbol":
+    case "function": {
+      return type;
+    }
   }
-  static not(domain) {
-    const result = new _Domain(domain);
-    result.ast.value.unshift({ type: 1, value: "!" });
-    return result;
+  if (Array.isArray(val))
+    return "array";
+  if (isDate(val))
+    return "date";
+  if (isError(val))
+    return "error";
+  const constructorName = ctorName(val);
+  switch (constructorName) {
+    case "Symbol":
+    case "Promise":
+    case "WeakMap":
+    case "WeakSet":
+    case "Map":
+    case "Set":
+      return constructorName;
   }
-  static removeDomainLeaves(domain, keysToRemove) {
-    function processLeaf(elements, idx, operatorCtx, newDomain2) {
-      const leaf = elements[idx];
-      if (leaf.type === 10) {
-        if (keysToRemove.includes(leaf.value[0].value)) {
-          if (operatorCtx === "&") {
-            newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
-          } else if (operatorCtx === "|") {
-            newDomain2.ast.value.push(..._Domain.FALSE.ast.value);
-          }
-        } else {
-          newDomain2.ast.value.push(leaf);
-        }
-        return 1;
-      } else if (leaf.type === 1) {
-        if (leaf.value === "|" && elements[idx + 1].type === 10 && elements[idx + 2].type === 10 && keysToRemove.includes(elements[idx + 1].value[0].value) && keysToRemove.includes(elements[idx + 2].value[0].value)) {
-          newDomain2.ast.value.push(..._Domain.TRUE.ast.value);
-          return 3;
-        }
-        newDomain2.ast.value.push(leaf);
-        if (leaf.value === "!") {
-          return 1 + processLeaf(elements, idx + 1, "&", newDomain2);
-        }
-        const firstLeafSkip = processLeaf(
-          elements,
-          idx + 1,
-          leaf.value,
-          newDomain2
-        );
-        const secondLeafSkip = processLeaf(
-          elements,
-          idx + 1 + firstLeafSkip,
-          leaf.value,
-          newDomain2
-        );
-        return 1 + firstLeafSkip + secondLeafSkip;
-      }
-      return 0;
-    }
-    const d = new _Domain(domain);
-    if (d.ast.value.length === 0) {
-      return d;
-    }
-    const newDomain = new _Domain([]);
-    processLeaf(d.ast.value, 0, "&", newDomain);
-    return newDomain;
+  return Object.prototype.toString.call(val).slice(8, -1).toLowerCase().replace(/\s/g, "");
+}
+function ctorName(val) {
+  return typeof val.constructor === "function" ? val.constructor.name : null;
+}
+function isError(val) {
+  return val instanceof Error || typeof val.message === "string" && val.constructor && typeof val.constructor.stackTraceLimit === "number";
+}
+function isDate(val) {
+  if (val instanceof Date)
+    return true;
+  return typeof val.toDateString === "function" && typeof val.getDate === "function" && typeof val.setDate === "function";
+}
+function kindOf(val) {
+  let typeOfVal = typeof val;
+  if (process.env.NODE_ENV !== "production") {
+    typeOfVal = miniKindOf(val);
   }
-  constructor(descr = []) {
-    if (descr instanceof _Domain) {
-      return new _Domain(descr.toString());
-    } else {
-      let rawAST;
-      try {
-        rawAST = typeof descr === "string" ? parseExpr(descr) : toAST(descr);
-      } catch (error) {
-        throw new InvalidDomainError(
-          `Invalid domain representation: ${descr}`,
-          {
-            cause: error
-          }
-        );
-      }
-      this.ast = normalizeDomainAST(rawAST);
-    }
+  return typeOfVal;
+}
+function warning(message) {
+  if (typeof console !== "undefined" && typeof console.error === "function") {
+    console.error(message);
   }
-  contains(record) {
-    const expr = evaluate(this.ast, record);
-    return matchDomain(record, expr);
+  try {
+    throw new Error(message);
+  } catch (e) {
   }
-  toString() {
-    return formatAST(this.ast);
+}
+function getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) {
+  const reducerKeys = Object.keys(reducers);
+  const argumentName = action && action.type === actionTypes_default.INIT ? "preloadedState argument passed to createStore" : "previous state received by the reducer";
+  if (reducerKeys.length === 0) {
+    return "Store does not have a valid reducer. Make sure the argument passed to combineReducers is an object whose values are reducers.";
   }
-  toList(context) {
-    return evaluate(this.ast, context);
+  if (!isPlainObject(inputState)) {
+    return `The ${argumentName} has unexpected type of "${kindOf(inputState)}". Expected argument to be an object with the following keys: "${reducerKeys.join('", "')}"`;
   }
-  toJson() {
-    try {
-      const evaluatedAsList = this.toList({});
-      const evaluatedDomain = new _Domain(evaluatedAsList);
-      if (evaluatedDomain.toString() === this.toString()) {
-        return evaluatedAsList;
-      }
-      return this.toString();
-    } catch {
-      return this.toString();
-    }
+  const unexpectedKeys = Object.keys(inputState).filter((key) => !reducers.hasOwnProperty(key) && !unexpectedKeyCache[key]);
+  unexpectedKeys.forEach((key) => {
+    unexpectedKeyCache[key] = true;
+  });
+  if (action && action.type === actionTypes_default.REPLACE)
+    return;
+  if (unexpectedKeys.length > 0) {
+    return `Unexpected ${unexpectedKeys.length > 1 ? "keys" : "key"} "${unexpectedKeys.join('", "')}" found in ${argumentName}. Expected to find one of the known reducer keys instead: "${reducerKeys.join('", "')}". Unexpected keys will be ignored.`;
   }
-};
-var TRUE_LEAF = [1, "=", 1];
-var FALSE_LEAF = [0, "=", 1];
-var TRUE_DOMAIN = new Domain([TRUE_LEAF]);
-var FALSE_DOMAIN = new Domain([FALSE_LEAF]);
-Domain.TRUE = TRUE_DOMAIN;
-Domain.FALSE = FALSE_DOMAIN;
-function toAST(domain) {
-  const elems = domain.map((elem) => {
-    switch (elem) {
-      case "!":
-      case "&":
-      case "|":
-        return { type: 1, value: elem };
-      default:
-        return {
-          type: 10,
-          value: elem.map(toPyValue)
-        };
+}
+function assertReducerShape(reducers) {
+  Object.keys(reducers).forEach((key) => {
+    const reducer = reducers[key];
+    const initialState10 = reducer(void 0, {
+      type: actionTypes_default.INIT
+    });
+    if (typeof initialState10 === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(12) : `The slice reducer for key "${key}" returned undefined during initialization. If the state passed to the reducer is undefined, you must explicitly return the initial state. The initial state may not be undefined. If you don't want to set a value for this reducer, you can use null instead of undefined.`);
+    }
+    if (typeof reducer(void 0, {
+      type: actionTypes_default.PROBE_UNKNOWN_ACTION()
+    }) === "undefined") {
+      throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(13) : `The slice reducer for key "${key}" returned undefined when probed with a random type. Don't try to handle '${actionTypes_default.INIT}' or other actions in "redux/*" namespace. They are considered private. Instead, you must return the current state for any unknown actions, unless it is undefined, in which case you must return the initial state, regardless of the action type. The initial state may not be undefined, but can be null.`);
     }
   });
-  return { type: 4, value: elems };
 }
-function normalizeDomainAST(domain, op = "&") {
-  if (domain.type !== 4) {
-    if (domain.type === 10) {
-      const value = domain.value;
-      if (value.findIndex((e) => e.type === 10) === -1 || !value.every((e) => e.type === 10 || e.type === 1)) {
-        throw new InvalidDomainError("Invalid domain AST");
+function combineReducers(reducers) {
+  const reducerKeys = Object.keys(reducers);
+  const finalReducers = {};
+  for (let i = 0; i < reducerKeys.length; i++) {
+    const key = reducerKeys[i];
+    if (process.env.NODE_ENV !== "production") {
+      if (typeof reducers[key] === "undefined") {
+        warning(`No reducer provided for key "${key}"`);
       }
-    } else {
-      throw new InvalidDomainError("Invalid domain AST");
     }
-  }
-  if (domain.value.length === 0) {
-    return domain;
-  }
-  let expected = 1;
-  for (const child of domain.value) {
-    switch (child.type) {
-      case 1:
-        if (child.value === "&" || child.value === "|") {
-          expected++;
-        } else if (child.value !== "!") {
-          throw new InvalidDomainError("Invalid domain AST");
-        }
-        break;
-      case 4:
-      /* list */
-      case 10:
-        if (child.value.length === 3) {
-          expected--;
-          break;
-        }
-        throw new InvalidDomainError("Invalid domain AST");
-      default:
-        throw new InvalidDomainError("Invalid domain AST");
+    if (typeof reducers[key] === "function") {
+      finalReducers[key] = reducers[key];
     }
   }
-  const values = domain.value.slice();
-  while (expected < 0) {
-    expected++;
-    values.unshift({ type: 1, value: op });
-  }
-  if (expected > 0) {
-    throw new InvalidDomainError(
-      `invalid domain ${formatAST(domain)} (missing ${expected} segment(s))`
-    );
+  const finalReducerKeys = Object.keys(finalReducers);
+  let unexpectedKeyCache;
+  if (process.env.NODE_ENV !== "production") {
+    unexpectedKeyCache = {};
   }
-  return { type: 4, value: values };
-}
-function matchCondition(record, condition) {
-  if (typeof condition === "boolean") {
-    return condition;
+  let shapeAssertionError;
+  try {
+    assertReducerShape(finalReducers);
+  } catch (e) {
+    shapeAssertionError = e;
   }
-  const [field, operator, value] = condition;
-  if (typeof field === "string") {
-    const names = field.split(".");
-    if (names.length >= 2) {
-      return matchCondition(record[names[0]], [
-        names.slice(1).join("."),
-        operator,
-        value
-      ]);
+  return function combination(state = {}, action) {
+    if (shapeAssertionError) {
+      throw shapeAssertionError;
     }
-  }
-  let likeRegexp, ilikeRegexp;
-  if (["like", "not like", "ilike", "not ilike"].includes(operator)) {
-    likeRegexp = new RegExp(
-      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
-      "g"
-    );
-    ilikeRegexp = new RegExp(
-      `(.*)${escapeRegExp(value).replaceAll("%", "(.*)")}(.*)`,
-      "gi"
-    );
-  }
-  const fieldValue = typeof field === "number" ? field : record[field];
-  switch (operator) {
-    case "=?":
-      if ([false, null].includes(value)) {
-        return true;
-      }
-    // eslint-disable-next-line no-fallthrough
-    case "=":
-    case "==":
-      if (Array.isArray(fieldValue) && Array.isArray(value)) {
-        return shallowEqual2(fieldValue, value);
+    if (process.env.NODE_ENV !== "production") {
+      const warningMessage = getUnexpectedStateShapeWarningMessage(state, finalReducers, action, unexpectedKeyCache);
+      if (warningMessage) {
+        warning(warningMessage);
       }
-      return fieldValue === value;
-    case "!=":
-    case "<>":
-      return !matchCondition(record, [field, "==", value]);
-    case "<":
-      return fieldValue < value;
-    case "<=":
-      return fieldValue <= value;
-    case ">":
-      return fieldValue > value;
-    case ">=":
-      return fieldValue >= value;
-    case "in": {
-      const val = Array.isArray(value) ? value : [value];
-      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
-      return fieldVal.some((fv) => val.includes(fv));
-    }
-    case "not in": {
-      const val = Array.isArray(value) ? value : [value];
-      const fieldVal = Array.isArray(fieldValue) ? fieldValue : [fieldValue];
-      return !fieldVal.some((fv) => val.includes(fv));
     }
-    case "like":
-      if (fieldValue === false) {
-        return false;
-      }
-      return Boolean(fieldValue.match(likeRegexp));
-    case "not like":
-      if (fieldValue === false) {
-        return false;
-      }
-      return Boolean(!fieldValue.match(likeRegexp));
-    case "=like":
-      if (fieldValue === false) {
-        return false;
-      }
-      return new RegExp(escapeRegExp(value).replace(/%/g, ".*")).test(
-        fieldValue
-      );
-    case "ilike":
-      if (fieldValue === false) {
-        return false;
-      }
-      return Boolean(fieldValue.match(ilikeRegexp));
-    case "not ilike":
-      if (fieldValue === false) {
-        return false;
-      }
-      return Boolean(!fieldValue.match(ilikeRegexp));
-    case "=ilike":
-      if (fieldValue === false) {
-        return false;
+    let hasChanged = false;
+    const nextState = {};
+    for (let i = 0; i < finalReducerKeys.length; i++) {
+      const key = finalReducerKeys[i];
+      const reducer = finalReducers[key];
+      const previousStateForKey = state[key];
+      const nextStateForKey = reducer(previousStateForKey, action);
+      if (typeof nextStateForKey === "undefined") {
+        const actionType = action && action.type;
+        throw new Error(process.env.NODE_ENV === "production" ? formatProdErrorMessage(14) : `When called with an action of type ${actionType ? `"${String(actionType)}"` : "(unknown type)"}, the slice reducer for key "${key}" returned undefined. To ignore an action, you must explicitly return the previous state. If you want this reducer to hold no value, you can return null instead of undefined.`);
       }
-      return new RegExp(escapeRegExp(value).replace(/%/g, ".*"), "i").test(
-        fieldValue
-      );
-  }
-  throw new InvalidDomainError("could not match domain");
-}
-function makeOperators(record) {
-  const match = matchCondition.bind(null, record);
-  return {
-    "!": (x) => !match(x),
-    "&": (a, b) => match(a) && match(b),
-    "|": (a, b) => match(a) || match(b)
-  };
-}
-function matchDomain(record, domain) {
-  if (domain.length === 0) {
-    return true;
-  }
-  const operators = makeOperators(record);
-  const reversedDomain = Array.from(domain).reverse();
-  const condStack = [];
-  for (const item of reversedDomain) {
-    const operator = typeof item === "string" && operators[item];
-    if (operator) {
-      const operands = condStack.splice(-operator.length);
-      condStack.push(operator(...operands));
-    } else {
-      condStack.push(item);
+      nextState[key] = nextStateForKey;
+      hasChanged = hasChanged || nextStateForKey !== previousStateForKey;
     }
-  }
-  return matchCondition(record, condStack.pop());
+    hasChanged = hasChanged || finalReducerKeys.length !== Object.keys(state).length;
+    return hasChanged ? nextState : state;
+  };
 }
 
-// src/utils/function.ts
-import { useEffect, useState } from "react";
-var toQueryString = (params) => {
-  return Object.keys(params).map(
-    (key) => encodeURIComponent(key) + "=" + encodeURIComponent(params[key].toString())
-  ).join("&");
-};
+// src/store/store.ts
+var rootReducer = combineReducers({
+  env: env_slice_default,
+  header: header_slice_default,
+  navbar: navbar_slice_default,
+  list: list_slice_default,
+  search: search_slice_default,
+  form: form_slice_default,
+  breadcrumbs: breadcrums_slice_default,
+  login: login_slice_default,
+  excel: excel_slice_default,
+  profile: profile_slice_default
+});
+var envStore = configureStore({
+  reducer: rootReducer,
+  middleware: (getDefaultMiddleware) => getDefaultMiddleware({
+    serializableCheck: false
+  })
+});
 
 // src/environment/EnvStore.ts
-var requests = {
-  get: async (url, headers) => ({}),
-  post: async (url, body, headers) => ({}),
-  post_excel: async (url, body, headers) => ({}),
-  put: async (url, body, headers) => ({}),
-  patch: async (url, body) => ({}),
-  delete: async (url, body) => ({})
+var EnvStore = class _EnvStore {
+  static instance = null;
+  static localStorageUtils;
+  static sessionStorageUtils;
+  constructor() {
+  }
+  static getInstance(localStorageUtils2, sessionStorageUtils2) {
+    if (!_EnvStore.instance) {
+      console.log("Creating new EnvStore instance");
+      _EnvStore.instance = new _EnvStore();
+      _EnvStore.localStorageUtils = localStorageUtils2;
+      _EnvStore.sessionStorageUtils = sessionStorageUtils2;
+    } else {
+      console.log("Returning existing EnvStore instance");
+    }
+    return _EnvStore.instance;
+  }
+  static getState() {
+    const state = envStore.getState().env;
+    console.log("Redux env state:", state);
+    return {
+      baseUrl: state?.baseUrl,
+      requests: state?.requests,
+      context: state?.context,
+      defaultCompany: state?.defaultCompany,
+      config: state?.config,
+      companies: state?.companies || [],
+      user: state?.user,
+      db: state?.db,
+      refreshTokenEndpoint: state?.refreshTokenEndpoint,
+      uid: state?.uid,
+      lang: state?.lang,
+      allowCompanies: state?.allowCompanies
+    };
+  }
+  static setupEnv(envConfig) {
+    const dispatch = envStore.dispatch;
+    const env = {
+      ..._EnvStore.getState(),
+      ...envConfig,
+      localStorageUtils: _EnvStore.localStorageUtils,
+      sessionStorageUtils: _EnvStore.sessionStorageUtils
+    };
+    console.log("Setting up env with config:", envConfig);
+    const requests = axiosClient.init(env);
+    console.log("axiosClient.init result:", requests);
+    dispatch(setEnv({ ...env, requests }));
+  }
+  static setUid(uid) {
+    const dispatch = envStore.dispatch;
+    dispatch(setUid(uid));
+  }
+  static setLang(lang) {
+    const dispatch = envStore.dispatch;
+    dispatch(setLang(lang));
+  }
+  static setAllowCompanies(allowCompanies) {
+    const dispatch = envStore.dispatch;
+    dispatch(setAllowCompanies(allowCompanies));
+  }
+  static setCompanies(companies) {
+    const dispatch = envStore.dispatch;
+    dispatch(setCompanies(companies));
+  }
+  static setDefaultCompany(company) {
+    const dispatch = envStore.dispatch;
+    dispatch(setDefaultCompany(company));
+  }
+  static setUserInfo(userInfo) {
+    const dispatch = envStore.dispatch;
+    dispatch(setUser(userInfo));
+  }
 };
 function getEnv() {
-  const env = envStore.getState().env;
-  return { ...env, requests };
+  return EnvStore.getState();
 }
 
 // src/services/action-service/index.ts
@@ -2947,7 +3237,7 @@ var AuthService = {
       }).filter(([_, value]) => !!value)
     );
     const encodedData = new URLSearchParams(payload).toString();
-    return env?.requests?.post(body?.path ?? "", encodedData, {
+    return env?.requests?.post(body.path, encodedData, {
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       }
@@ -3044,20 +3334,6 @@ var AuthService = {
       }
     });
   },
-  async isValidActionToken(actionToken, path) {
-    const env = getEnv();
-    return env?.requests?.post(
-      path,
-      {},
-      {
-        headers: {
-          "Content-Type": "application/json"
-        },
-        useActionToken: true,
-        actionToken
-      }
-    );
-  },
   async loginSocial({
     db,
     state,
@@ -3822,7 +4098,7 @@ var model_service_default = ModelService;
 var UserService = {
   async getProfile(path) {
     const env = getEnv();
-    return env?.requests?.get(path ?? "/userinfo" /* PROFILE_PATH */, {
+    return env.requests.get(path ?? "/userinfo" /* PROFILE_PATH */, {
       headers: {
         "Content-Type": "application/x-www-form-urlencoded"
       }
@@ -4141,7 +4417,8 @@ var ViewService = {
   },
   async getVersion() {
     const env = getEnv();
-    return env?.requests.get("", {
+    console.log("env?.requests", env, env?.requests);
+    return env?.requests?.get("", {
       headers: {
         "Content-Type": "application/json"
       }