fix: 修复关闭SSH终端标签页时会话状态未更新的问题

web/node_modules/.vite/deps/@ant-design_colors.js

@@ -0,0 +1,70 @@
+import {
+  blue,
+  blueDark,
+  cyan,
+  cyanDark,
+  geekblue,
+  geekblueDark,
+  generate,
+  gold,
+  goldDark,
+  gray,
+  green,
+  greenDark,
+  grey,
+  greyDark,
+  init_es2 as init_es,
+  lime,
+  limeDark,
+  magenta,
+  magentaDark,
+  orange,
+  orangeDark,
+  presetDarkPalettes,
+  presetPalettes,
+  presetPrimaryColors,
+  purple,
+  purpleDark,
+  red,
+  redDark,
+  volcano,
+  volcanoDark,
+  yellow,
+  yellowDark
+} from "./chunk-5T3YOWZX.js";
+import "./chunk-R546NDVX.js";
+import "./chunk-V4OQ3NZ2.js";
+init_es();
+export {
+  blue,
+  blueDark,
+  cyan,
+  cyanDark,
+  geekblue,
+  geekblueDark,
+  generate,
+  gold,
+  goldDark,
+  gray,
+  green,
+  greenDark,
+  grey,
+  greyDark,
+  lime,
+  limeDark,
+  magenta,
+  magentaDark,
+  orange,
+  orangeDark,
+  presetDarkPalettes,
+  presetPalettes,
+  presetPrimaryColors,
+  purple,
+  purpleDark,
+  red,
+  redDark,
+  volcano,
+  volcanoDark,
+  yellow,
+  yellowDark
+};

web/node_modules/.vite/deps/@ant-design_colors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@ant-design_cssinjs.js

@@ -0,0 +1,52 @@
+import {
+  Keyframes_default,
+  NaNLinter_default,
+  StyleContext_default,
+  StyleProvider,
+  Theme,
+  _experimental,
+  calc_default,
+  createCache,
+  createTheme,
+  extractStyle,
+  getComputedToken,
+  legacyLogicalProperties_default,
+  legacyNotSelectorLinter_default,
+  logicalPropertiesLinter_default,
+  parentSelectorLinter_default,
+  px2rem_default,
+  token2CSSVar,
+  unit,
+  useCSSVarRegister_default,
+  useCacheToken,
+  useStyleRegister
+} from "./chunk-DINYHDVU.js";
+import "./chunk-FSGBSGQ2.js";
+import "./chunk-KBMHTFOP.js";
+import "./chunk-4NTHFIFD.js";
+import "./chunk-7ZNOTH45.js";
+import "./chunk-R546NDVX.js";
+import "./chunk-V4OQ3NZ2.js";
+export {
+  Keyframes_default as Keyframes,
+  NaNLinter_default as NaNLinter,
+  StyleContext_default as StyleContext,
+  StyleProvider,
+  Theme,
+  _experimental,
+  createCache,
+  createTheme,
+  extractStyle,
+  calc_default as genCalc,
+  getComputedToken,
+  legacyLogicalProperties_default as legacyLogicalPropertiesTransformer,
+  legacyNotSelectorLinter_default as legacyNotSelectorLinter,
+  logicalPropertiesLinter_default as logicalPropertiesLinter,
+  parentSelectorLinter_default as parentSelectorLinter,
+  px2rem_default as px2remTransformer,
+  token2CSSVar,
+  unit,
+  useCSSVarRegister_default as useCSSVarRegister,
+  useCacheToken,
+  useStyleRegister
+};

web/node_modules/.vite/deps/@ant-design_cssinjs.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@ant-design_icons.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@dnd-kit_core.js

@@ -0,0 +1,70 @@
+import {
+  AutoScrollActivator,
+  DndContext,
+  DragOverlay,
+  KeyboardCode,
+  KeyboardSensor,
+  MeasuringFrequency,
+  MeasuringStrategy,
+  MouseSensor,
+  PointerSensor,
+  TouchSensor,
+  TraversalOrder,
+  applyModifiers,
+  closestCenter,
+  closestCorners,
+  defaultAnnouncements,
+  defaultCoordinates,
+  defaultDropAnimationConfiguration,
+  defaultDropAnimationSideEffects,
+  defaultKeyboardCoordinateGetter,
+  defaultScreenReaderInstructions,
+  getClientRect,
+  getFirstCollision,
+  getScrollableAncestors,
+  pointerWithin,
+  rectIntersection,
+  useDndContext,
+  useDndMonitor,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors
+} from "./chunk-6VAXZ5AU.js";
+import "./chunk-3DUEC4BE.js";
+import "./chunk-MNF4PNE3.js";
+import "./chunk-7ZNOTH45.js";
+import "./chunk-V4OQ3NZ2.js";
+export {
+  AutoScrollActivator,
+  DndContext,
+  DragOverlay,
+  KeyboardCode,
+  KeyboardSensor,
+  MeasuringFrequency,
+  MeasuringStrategy,
+  MouseSensor,
+  PointerSensor,
+  TouchSensor,
+  TraversalOrder,
+  applyModifiers,
+  closestCenter,
+  closestCorners,
+  defaultAnnouncements,
+  defaultCoordinates,
+  defaultDropAnimationConfiguration as defaultDropAnimation,
+  defaultDropAnimationSideEffects,
+  defaultKeyboardCoordinateGetter,
+  defaultScreenReaderInstructions,
+  getClientRect,
+  getFirstCollision,
+  getScrollableAncestors,
+  pointerWithin,
+  rectIntersection,
+  useDndContext,
+  useDndMonitor,
+  useDraggable,
+  useDroppable,
+  useSensor,
+  useSensors
+};

web/node_modules/.vite/deps/@dnd-kit_core.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@dnd-kit_sortable.js

@@ -0,0 +1,33 @@
+import {
+  SortableContext,
+  arrayMove,
+  arraySwap,
+  defaultAnimateLayoutChanges,
+  defaultNewIndexGetter,
+  hasSortableData,
+  horizontalListSortingStrategy,
+  rectSortingStrategy,
+  rectSwappingStrategy,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy
+} from "./chunk-LSZRMDFG.js";
+import "./chunk-6VAXZ5AU.js";
+import "./chunk-3DUEC4BE.js";
+import "./chunk-MNF4PNE3.js";
+import "./chunk-7ZNOTH45.js";
+import "./chunk-V4OQ3NZ2.js";
+export {
+  SortableContext,
+  arrayMove,
+  arraySwap,
+  defaultAnimateLayoutChanges,
+  defaultNewIndexGetter,
+  hasSortableData,
+  horizontalListSortingStrategy,
+  rectSortingStrategy,
+  rectSwappingStrategy,
+  sortableKeyboardCoordinates,
+  useSortable,
+  verticalListSortingStrategy
+};

web/node_modules/.vite/deps/@dnd-kit_sortable.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@dnd-kit_utilities.js

@@ -0,0 +1,56 @@
+import {
+  CSS,
+  add,
+  canUseDOM,
+  findFirstFocusableNode,
+  getEventCoordinates,
+  getOwnerDocument,
+  getWindow,
+  hasViewportRelativeCoordinates,
+  isDocument,
+  isHTMLElement,
+  isKeyboardEvent,
+  isNode,
+  isSVGElement,
+  isTouchEvent,
+  isWindow,
+  subtract,
+  useCombinedRefs,
+  useEvent,
+  useInterval,
+  useIsomorphicLayoutEffect,
+  useLatestValue,
+  useLazyMemo,
+  useNodeRef,
+  usePrevious,
+  useUniqueId
+} from "./chunk-3DUEC4BE.js";
+import "./chunk-7ZNOTH45.js";
+import "./chunk-V4OQ3NZ2.js";
+export {
+  CSS,
+  add,
+  canUseDOM,
+  findFirstFocusableNode,
+  getEventCoordinates,
+  getOwnerDocument,
+  getWindow,
+  hasViewportRelativeCoordinates,
+  isDocument,
+  isHTMLElement,
+  isKeyboardEvent,
+  isNode,
+  isSVGElement,
+  isTouchEvent,
+  isWindow,
+  subtract,
+  useCombinedRefs,
+  useEvent,
+  useInterval,
+  useIsomorphicLayoutEffect,
+  useLatestValue,
+  useLazyMemo,
+  useNodeRef,
+  usePrevious,
+  useUniqueId
+};

web/node_modules/.vite/deps/@dnd-kit_utilities.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/@monaco-editor_react.js

@@ -0,0 +1,671 @@
+import {
+  require_react
+} from "./chunk-7ZNOTH45.js";
+import {
+  __toESM
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@monaco-editor/loader/lib/es/_virtual/_rollupPluginBabelHelpers.js
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+function _defineProperty(e, r, t) {
+  return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+function _iterableToArrayLimit(r, l2) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l2) ;
+      else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l2); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o, r, i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+// node_modules/state-local/lib/es/state-local.js
+function _defineProperty2(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+function ownKeys2(object, enumerableOnly) {
+  var keys = Object.keys(object);
+  if (Object.getOwnPropertySymbols) {
+    var symbols = Object.getOwnPropertySymbols(object);
+    if (enumerableOnly) symbols = symbols.filter(function(sym) {
+      return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+    });
+    keys.push.apply(keys, symbols);
+  }
+  return keys;
+}
+function _objectSpread22(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    if (i % 2) {
+      ownKeys2(Object(source), true).forEach(function(key) {
+        _defineProperty2(target, key, source[key]);
+      });
+    } else if (Object.getOwnPropertyDescriptors) {
+      Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+      ownKeys2(Object(source)).forEach(function(key) {
+        Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+      });
+    }
+  }
+  return target;
+}
+function compose() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function(x) {
+    return fns.reduceRight(function(y, f) {
+      return f(y);
+    }, x);
+  };
+}
+function curry(fn) {
+  return function curried() {
+    var _this = this;
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    return args.length >= fn.length ? fn.apply(this, args) : function() {
+      for (var _len3 = arguments.length, nextArgs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        nextArgs[_key3] = arguments[_key3];
+      }
+      return curried.apply(_this, [].concat(args, nextArgs));
+    };
+  };
+}
+function isObject(value) {
+  return {}.toString.call(value).includes("Object");
+}
+function isEmpty(obj) {
+  return !Object.keys(obj).length;
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function hasOwnProperty(object, property) {
+  return Object.prototype.hasOwnProperty.call(object, property);
+}
+function validateChanges(initial, changes) {
+  if (!isObject(changes)) errorHandler("changeType");
+  if (Object.keys(changes).some(function(field) {
+    return !hasOwnProperty(initial, field);
+  })) errorHandler("changeField");
+  return changes;
+}
+function validateSelector(selector) {
+  if (!isFunction(selector)) errorHandler("selectorType");
+}
+function validateHandler(handler) {
+  if (!(isFunction(handler) || isObject(handler))) errorHandler("handlerType");
+  if (isObject(handler) && Object.values(handler).some(function(_handler) {
+    return !isFunction(_handler);
+  })) errorHandler("handlersType");
+}
+function validateInitial(initial) {
+  if (!initial) errorHandler("initialIsRequired");
+  if (!isObject(initial)) errorHandler("initialType");
+  if (isEmpty(initial)) errorHandler("initialContent");
+}
+function throwError(errorMessages3, type) {
+  throw new Error(errorMessages3[type] || errorMessages3["default"]);
+}
+var errorMessages = {
+  initialIsRequired: "initial state is required",
+  initialType: "initial state should be an object",
+  initialContent: "initial state shouldn't be an empty object",
+  handlerType: "handler should be an object or a function",
+  handlersType: "all handlers should be a functions",
+  selectorType: "selector should be a function",
+  changeType: "provided value of changes should be an object",
+  changeField: 'it seams you want to change a field in the state which is not specified in the "initial" state',
+  "default": "an unknown error accured in `state-local` package"
+};
+var errorHandler = curry(throwError)(errorMessages);
+var validators = {
+  changes: validateChanges,
+  selector: validateSelector,
+  handler: validateHandler,
+  initial: validateInitial
+};
+function create(initial) {
+  var handler = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  validators.initial(initial);
+  validators.handler(handler);
+  var state = {
+    current: initial
+  };
+  var didUpdate = curry(didStateUpdate)(state, handler);
+  var update = curry(updateState)(state);
+  var validate = curry(validators.changes)(initial);
+  var getChanges = curry(extractChanges)(state);
+  function getState2() {
+    var selector = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function(state2) {
+      return state2;
+    };
+    validators.selector(selector);
+    return selector(state.current);
+  }
+  function setState2(causedChanges) {
+    compose(didUpdate, update, validate, getChanges)(causedChanges);
+  }
+  return [getState2, setState2];
+}
+function extractChanges(state, causedChanges) {
+  return isFunction(causedChanges) ? causedChanges(state.current) : causedChanges;
+}
+function updateState(state, changes) {
+  state.current = _objectSpread22(_objectSpread22({}, state.current), changes);
+  return changes;
+}
+function didStateUpdate(state, handler, changes) {
+  isFunction(handler) ? handler(state.current) : Object.keys(changes).forEach(function(field) {
+    var _handler$field;
+    return (_handler$field = handler[field]) === null || _handler$field === void 0 ? void 0 : _handler$field.call(handler, state.current[field]);
+  });
+  return changes;
+}
+var index = {
+  create
+};
+var state_local_default = index;
+
+// node_modules/@monaco-editor/loader/lib/es/config/index.js
+var config = {
+  paths: {
+    vs: "https://cdn.jsdelivr.net/npm/monaco-editor@0.55.1/min/vs"
+  }
+};
+
+// node_modules/@monaco-editor/loader/lib/es/utils/curry.js
+function curry2(fn) {
+  return function curried() {
+    var _this = this;
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return args.length >= fn.length ? fn.apply(this, args) : function() {
+      for (var _len2 = arguments.length, nextArgs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        nextArgs[_key2] = arguments[_key2];
+      }
+      return curried.apply(_this, [].concat(args, nextArgs));
+    };
+  };
+}
+
+// node_modules/@monaco-editor/loader/lib/es/utils/isObject.js
+function isObject2(value) {
+  return {}.toString.call(value).includes("Object");
+}
+
+// node_modules/@monaco-editor/loader/lib/es/validators/index.js
+function validateConfig(config3) {
+  if (!config3) errorHandler2("configIsRequired");
+  if (!isObject2(config3)) errorHandler2("configType");
+  if (config3.urls) {
+    informAboutDeprecation();
+    return {
+      paths: {
+        vs: config3.urls.monacoBase
+      }
+    };
+  }
+  return config3;
+}
+function informAboutDeprecation() {
+  console.warn(errorMessages2.deprecation);
+}
+function throwError2(errorMessages3, type) {
+  throw new Error(errorMessages3[type] || errorMessages3["default"]);
+}
+var errorMessages2 = {
+  configIsRequired: "the configuration object is required",
+  configType: "the configuration object should be an object",
+  "default": "an unknown error accured in `@monaco-editor/loader` package",
+  deprecation: "Deprecation warning!\n    You are using deprecated way of configuration.\n\n    Instead of using\n      monaco.config({ urls: { monacoBase: '...' } })\n    use\n      monaco.config({ paths: { vs: '...' } })\n\n    For more please check the link https://github.com/suren-atoyan/monaco-loader#config\n  "
+};
+var errorHandler2 = curry2(throwError2)(errorMessages2);
+var validators2 = {
+  config: validateConfig
+};
+
+// node_modules/@monaco-editor/loader/lib/es/utils/compose.js
+var compose2 = function compose3() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function(x) {
+    return fns.reduceRight(function(y, f) {
+      return f(y);
+    }, x);
+  };
+};
+
+// node_modules/@monaco-editor/loader/lib/es/utils/deepMerge.js
+function merge(target, source) {
+  Object.keys(source).forEach(function(key) {
+    if (source[key] instanceof Object) {
+      if (target[key]) {
+        Object.assign(source[key], merge(target[key], source[key]));
+      }
+    }
+  });
+  return _objectSpread2(_objectSpread2({}, target), source);
+}
+
+// node_modules/@monaco-editor/loader/lib/es/utils/makeCancelable.js
+var CANCELATION_MESSAGE = {
+  type: "cancelation",
+  msg: "operation is manually canceled"
+};
+function makeCancelable(promise) {
+  var hasCanceled_ = false;
+  var wrappedPromise = new Promise(function(resolve, reject) {
+    promise.then(function(val) {
+      return hasCanceled_ ? reject(CANCELATION_MESSAGE) : resolve(val);
+    });
+    promise["catch"](reject);
+  });
+  return wrappedPromise.cancel = function() {
+    return hasCanceled_ = true;
+  }, wrappedPromise;
+}
+
+// node_modules/@monaco-editor/loader/lib/es/loader/index.js
+var _excluded = ["monaco"];
+var _state$create = state_local_default.create({
+  config,
+  isInitialized: false,
+  resolve: null,
+  reject: null,
+  monaco: null
+});
+var _state$create2 = _slicedToArray(_state$create, 2);
+var getState = _state$create2[0];
+var setState = _state$create2[1];
+function config2(globalConfig) {
+  var _validators$config = validators2.config(globalConfig), monaco = _validators$config.monaco, config3 = _objectWithoutProperties(_validators$config, _excluded);
+  setState(function(state) {
+    return {
+      config: merge(state.config, config3),
+      monaco
+    };
+  });
+}
+function init() {
+  var state = getState(function(_ref) {
+    var monaco = _ref.monaco, isInitialized = _ref.isInitialized, resolve = _ref.resolve;
+    return {
+      monaco,
+      isInitialized,
+      resolve
+    };
+  });
+  if (!state.isInitialized) {
+    setState({
+      isInitialized: true
+    });
+    if (state.monaco) {
+      state.resolve(state.monaco);
+      return makeCancelable(wrapperPromise);
+    }
+    if (window.monaco && window.monaco.editor) {
+      storeMonacoInstance(window.monaco);
+      state.resolve(window.monaco);
+      return makeCancelable(wrapperPromise);
+    }
+    compose2(injectScripts, getMonacoLoaderScript)(configureLoader);
+  }
+  return makeCancelable(wrapperPromise);
+}
+function injectScripts(script) {
+  return document.body.appendChild(script);
+}
+function createScript(src) {
+  var script = document.createElement("script");
+  return src && (script.src = src), script;
+}
+function getMonacoLoaderScript(configureLoader2) {
+  var state = getState(function(_ref2) {
+    var config3 = _ref2.config, reject = _ref2.reject;
+    return {
+      config: config3,
+      reject
+    };
+  });
+  var loaderScript = createScript("".concat(state.config.paths.vs, "/loader.js"));
+  loaderScript.onload = function() {
+    return configureLoader2();
+  };
+  loaderScript.onerror = state.reject;
+  return loaderScript;
+}
+function configureLoader() {
+  var state = getState(function(_ref3) {
+    var config3 = _ref3.config, resolve = _ref3.resolve, reject = _ref3.reject;
+    return {
+      config: config3,
+      resolve,
+      reject
+    };
+  });
+  var require2 = window.require;
+  require2.config(state.config);
+  require2(["vs/editor/editor.main"], function(loaded) {
+    var monaco = loaded.m || loaded;
+    storeMonacoInstance(monaco);
+    state.resolve(monaco);
+  }, function(error) {
+    state.reject(error);
+  });
+}
+function storeMonacoInstance(monaco) {
+  if (!getState().monaco) {
+    setState({
+      monaco
+    });
+  }
+}
+function __getMonacoInstance() {
+  return getState(function(_ref4) {
+    var monaco = _ref4.monaco;
+    return monaco;
+  });
+}
+var wrapperPromise = new Promise(function(resolve, reject) {
+  return setState({
+    resolve,
+    reject
+  });
+});
+var loader = {
+  config: config2,
+  init,
+  __getMonacoInstance
+};
+
+// node_modules/@monaco-editor/react/dist/index.mjs
+var import_react = __toESM(require_react(), 1);
+var import_react2 = __toESM(require_react(), 1);
+var import_react3 = __toESM(require_react(), 1);
+var import_react4 = __toESM(require_react(), 1);
+var import_react5 = __toESM(require_react(), 1);
+var import_react6 = __toESM(require_react(), 1);
+var import_react7 = __toESM(require_react(), 1);
+var import_react8 = __toESM(require_react(), 1);
+var import_react9 = __toESM(require_react(), 1);
+var import_react10 = __toESM(require_react(), 1);
+var import_react11 = __toESM(require_react(), 1);
+var le = { wrapper: { display: "flex", position: "relative", textAlign: "initial" }, fullWidth: { width: "100%" }, hide: { display: "none" } };
+var v = le;
+var ae = { container: { display: "flex", height: "100%", width: "100%", justifyContent: "center", alignItems: "center" } };
+var Y = ae;
+function Me({ children: e }) {
+  return import_react5.default.createElement("div", { style: Y.container }, e);
+}
+var Z = Me;
+var $ = Z;
+function Ee({ width: e, height: r, isEditorReady: n, loading: t, _ref: a, className: m, wrapperProps: E }) {
+  return import_react4.default.createElement("section", { style: { ...v.wrapper, width: e, height: r }, ...E }, !n && import_react4.default.createElement($, null, t), import_react4.default.createElement("div", { ref: a, style: { ...v.fullWidth, ...!n && v.hide }, className: m }));
+}
+var ee = Ee;
+var H = (0, import_react3.memo)(ee);
+function Ce(e) {
+  (0, import_react6.useEffect)(e, []);
+}
+var k = Ce;
+function he(e, r, n = true) {
+  let t = (0, import_react7.useRef)(true);
+  (0, import_react7.useEffect)(t.current || !n ? () => {
+    t.current = false;
+  } : e, r);
+}
+var l = he;
+function D() {
+}
+function h(e, r, n, t) {
+  return De(e, t) || be(e, r, n, t);
+}
+function De(e, r) {
+  return e.editor.getModel(te(e, r));
+}
+function be(e, r, n, t) {
+  return e.editor.createModel(r, n, t ? te(e, t) : void 0);
+}
+function te(e, r) {
+  return e.Uri.parse(r);
+}
+function Oe({ original: e, modified: r, language: n, originalLanguage: t, modifiedLanguage: a, originalModelPath: m, modifiedModelPath: E, keepCurrentOriginalModel: g = false, keepCurrentModifiedModel: N = false, theme: x = "light", loading: P = "Loading...", options: y = {}, height: V = "100%", width: z = "100%", className: F, wrapperProps: j = {}, beforeMount: A = D, onMount: q = D }) {
+  let [M, O] = (0, import_react2.useState)(false), [T, s] = (0, import_react2.useState)(true), u = (0, import_react2.useRef)(null), c = (0, import_react2.useRef)(null), w = (0, import_react2.useRef)(null), d = (0, import_react2.useRef)(q), o = (0, import_react2.useRef)(A), b = (0, import_react2.useRef)(false);
+  k(() => {
+    let i = loader.init();
+    return i.then((f) => (c.current = f) && s(false)).catch((f) => f?.type !== "cancelation" && console.error("Monaco initialization: error:", f)), () => u.current ? I() : i.cancel();
+  }), l(() => {
+    if (u.current && c.current) {
+      let i = u.current.getOriginalEditor(), f = h(c.current, e || "", t || n || "text", m || "");
+      f !== i.getModel() && i.setModel(f);
+    }
+  }, [m], M), l(() => {
+    if (u.current && c.current) {
+      let i = u.current.getModifiedEditor(), f = h(c.current, r || "", a || n || "text", E || "");
+      f !== i.getModel() && i.setModel(f);
+    }
+  }, [E], M), l(() => {
+    let i = u.current.getModifiedEditor();
+    i.getOption(c.current.editor.EditorOption.readOnly) ? i.setValue(r || "") : r !== i.getValue() && (i.executeEdits("", [{ range: i.getModel().getFullModelRange(), text: r || "", forceMoveMarkers: true }]), i.pushUndoStop());
+  }, [r], M), l(() => {
+    u.current?.getModel()?.original.setValue(e || "");
+  }, [e], M), l(() => {
+    let { original: i, modified: f } = u.current.getModel();
+    c.current.editor.setModelLanguage(i, t || n || "text"), c.current.editor.setModelLanguage(f, a || n || "text");
+  }, [n, t, a], M), l(() => {
+    c.current?.editor.setTheme(x);
+  }, [x], M), l(() => {
+    u.current?.updateOptions(y);
+  }, [y], M);
+  let L = (0, import_react2.useCallback)(() => {
+    if (!c.current) return;
+    o.current(c.current);
+    let i = h(c.current, e || "", t || n || "text", m || ""), f = h(c.current, r || "", a || n || "text", E || "");
+    u.current?.setModel({ original: i, modified: f });
+  }, [n, r, a, e, t, m, E]), U = (0, import_react2.useCallback)(() => {
+    !b.current && w.current && (u.current = c.current.editor.createDiffEditor(w.current, { automaticLayout: true, ...y }), L(), c.current?.editor.setTheme(x), O(true), b.current = true);
+  }, [y, x, L]);
+  (0, import_react2.useEffect)(() => {
+    M && d.current(u.current, c.current);
+  }, [M]), (0, import_react2.useEffect)(() => {
+    !T && !M && U();
+  }, [T, M, U]);
+  function I() {
+    let i = u.current?.getModel();
+    g || i?.original?.dispose(), N || i?.modified?.dispose(), u.current?.dispose();
+  }
+  return import_react2.default.createElement(H, { width: z, height: V, isEditorReady: M, loading: P, _ref: w, className: F, wrapperProps: j });
+}
+var ie = Oe;
+var we = (0, import_react.memo)(ie);
+function Pe() {
+  let [e, r] = (0, import_react8.useState)(loader.__getMonacoInstance());
+  return k(() => {
+    let n;
+    return e || (n = loader.init(), n.then((t) => {
+      r(t);
+    })), () => n?.cancel();
+  }), e;
+}
+var Le = Pe;
+function He(e) {
+  let r = (0, import_react11.useRef)();
+  return (0, import_react11.useEffect)(() => {
+    r.current = e;
+  }, [e]), r.current;
+}
+var se = He;
+var _ = /* @__PURE__ */ new Map();
+function Ve({ defaultValue: e, defaultLanguage: r, defaultPath: n, value: t, language: a, path: m, theme: E = "light", line: g, loading: N = "Loading...", options: x = {}, overrideServices: P = {}, saveViewState: y = true, keepCurrentModel: V = false, width: z = "100%", height: F = "100%", className: j, wrapperProps: A = {}, beforeMount: q = D, onMount: M = D, onChange: O, onValidate: T = D }) {
+  let [s, u] = (0, import_react10.useState)(false), [c, w] = (0, import_react10.useState)(true), d = (0, import_react10.useRef)(null), o = (0, import_react10.useRef)(null), b = (0, import_react10.useRef)(null), L = (0, import_react10.useRef)(M), U = (0, import_react10.useRef)(q), I = (0, import_react10.useRef)(), i = (0, import_react10.useRef)(t), f = se(m), Q = (0, import_react10.useRef)(false), B = (0, import_react10.useRef)(false);
+  k(() => {
+    let p = loader.init();
+    return p.then((R) => (d.current = R) && w(false)).catch((R) => R?.type !== "cancelation" && console.error("Monaco initialization: error:", R)), () => o.current ? pe() : p.cancel();
+  }), l(() => {
+    let p = h(d.current, e || t || "", r || a || "", m || n || "");
+    p !== o.current?.getModel() && (y && _.set(f, o.current?.saveViewState()), o.current?.setModel(p), y && o.current?.restoreViewState(_.get(m)));
+  }, [m], s), l(() => {
+    o.current?.updateOptions(x);
+  }, [x], s), l(() => {
+    !o.current || t === void 0 || (o.current.getOption(d.current.editor.EditorOption.readOnly) ? o.current.setValue(t) : t !== o.current.getValue() && (B.current = true, o.current.executeEdits("", [{ range: o.current.getModel().getFullModelRange(), text: t, forceMoveMarkers: true }]), o.current.pushUndoStop(), B.current = false));
+  }, [t], s), l(() => {
+    let p = o.current?.getModel();
+    p && a && d.current?.editor.setModelLanguage(p, a);
+  }, [a], s), l(() => {
+    g !== void 0 && o.current?.revealLine(g);
+  }, [g], s), l(() => {
+    d.current?.editor.setTheme(E);
+  }, [E], s);
+  let X = (0, import_react10.useCallback)(() => {
+    if (!(!b.current || !d.current) && !Q.current) {
+      U.current(d.current);
+      let p = m || n, R = h(d.current, t || e || "", r || a || "", p || "");
+      o.current = d.current?.editor.create(b.current, { model: R, automaticLayout: true, ...x }, P), y && o.current.restoreViewState(_.get(p)), d.current.editor.setTheme(E), g !== void 0 && o.current.revealLine(g), u(true), Q.current = true;
+    }
+  }, [e, r, n, t, a, m, x, P, y, E, g]);
+  (0, import_react10.useEffect)(() => {
+    s && L.current(o.current, d.current);
+  }, [s]), (0, import_react10.useEffect)(() => {
+    !c && !s && X();
+  }, [c, s, X]), i.current = t, (0, import_react10.useEffect)(() => {
+    s && O && (I.current?.dispose(), I.current = o.current?.onDidChangeModelContent((p) => {
+      B.current || O(o.current.getValue(), p);
+    }));
+  }, [s, O]), (0, import_react10.useEffect)(() => {
+    if (s) {
+      let p = d.current.editor.onDidChangeMarkers((R) => {
+        let G = o.current.getModel()?.uri;
+        if (G && R.find((J) => J.path === G.path)) {
+          let J = d.current.editor.getModelMarkers({ resource: G });
+          T?.(J);
+        }
+      });
+      return () => {
+        p?.dispose();
+      };
+    }
+    return () => {
+    };
+  }, [s, T]);
+  function pe() {
+    I.current?.dispose(), V ? y && _.set(m, o.current.saveViewState()) : o.current.getModel()?.dispose(), o.current.dispose();
+  }
+  return import_react10.default.createElement(H, { width: z, height: F, isEditorReady: s, loading: N, _ref: b, className: j, wrapperProps: A });
+}
+var fe = Ve;
+var de = (0, import_react9.memo)(fe);
+var Ft = de;
+export {
+  we as DiffEditor,
+  de as Editor,
+  Ft as default,
+  loader,
+  Le as useMonaco
+};
+//# sourceMappingURL=@monaco-editor_react.js.map

web/node_modules/.vite/deps/@simplewebauthn_browser.js

@@ -0,0 +1,443 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@simplewebauthn/browser/esm/helpers/bufferToBase64URLString.js
+function bufferToBase64URLString(buffer) {
+  const bytes = new Uint8Array(buffer);
+  let str = "";
+  for (const charCode of bytes) {
+    str += String.fromCharCode(charCode);
+  }
+  const base64String = btoa(str);
+  return base64String.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/base64URLStringToBuffer.js
+function base64URLStringToBuffer(base64URLString) {
+  const base64 = base64URLString.replace(/-/g, "+").replace(/_/g, "/");
+  const padLength = (4 - base64.length % 4) % 4;
+  const padded = base64.padEnd(base64.length + padLength, "=");
+  const binary = atob(padded);
+  const buffer = new ArrayBuffer(binary.length);
+  const bytes = new Uint8Array(buffer);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return buffer;
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/browserSupportsWebAuthn.js
+function browserSupportsWebAuthn() {
+  return _browserSupportsWebAuthnInternals.stubThis(globalThis?.PublicKeyCredential !== void 0 && typeof globalThis.PublicKeyCredential === "function");
+}
+var _browserSupportsWebAuthnInternals = {
+  stubThis: (value) => value
+};
+
+// node_modules/@simplewebauthn/browser/esm/helpers/toPublicKeyCredentialDescriptor.js
+function toPublicKeyCredentialDescriptor(descriptor) {
+  const { id } = descriptor;
+  return {
+    ...descriptor,
+    id: base64URLStringToBuffer(id),
+    /**
+     * `descriptor.transports` is an array of our `AuthenticatorTransportFuture` that includes newer
+     * transports that TypeScript's DOM lib is ignorant of. Convince TS that our list of transports
+     * are fine to pass to WebAuthn since browsers will recognize the new value.
+     */
+    transports: descriptor.transports
+  };
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/isValidDomain.js
+function isValidDomain(hostname) {
+  return (
+    // Consider localhost valid as well since it's okay wrt Secure Contexts
+    hostname === "localhost" || // Support punycode (ACE) or ascii labels and domains
+    /^((xn--[a-z0-9-]+|[a-z0-9]+(-[a-z0-9]+)*)\.)+([a-z]{2,}|xn--[a-z0-9-]+)$/i.test(hostname)
+  );
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/webAuthnError.js
+var WebAuthnError = class extends Error {
+  constructor({ message, code, cause, name }) {
+    super(message, { cause });
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.name = name ?? cause.name;
+    this.code = code;
+  }
+};
+
+// node_modules/@simplewebauthn/browser/esm/helpers/identifyRegistrationError.js
+function identifyRegistrationError({ error, options }) {
+  const { publicKey } = options;
+  if (!publicKey) {
+    throw Error("options was missing required publicKey property");
+  }
+  if (error.name === "AbortError") {
+    if (options.signal instanceof AbortSignal) {
+      return new WebAuthnError({
+        message: "Registration ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: error
+      });
+    }
+  } else if (error.name === "ConstraintError") {
+    if (publicKey.authenticatorSelection?.requireResidentKey === true) {
+      return new WebAuthnError({
+        message: "Discoverable credentials were required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_DISCOVERABLE_CREDENTIAL_SUPPORT",
+        cause: error
+      });
+    } else if (
+      // @ts-ignore: `mediation` doesn't yet exist on CredentialCreationOptions but it's possible as of Sept 2024
+      options.mediation === "conditional" && publicKey.authenticatorSelection?.userVerification === "required"
+    ) {
+      return new WebAuthnError({
+        message: "User verification was required during automatic registration but it could not be performed",
+        code: "ERROR_AUTO_REGISTER_USER_VERIFICATION_FAILURE",
+        cause: error
+      });
+    } else if (publicKey.authenticatorSelection?.userVerification === "required") {
+      return new WebAuthnError({
+        message: "User verification was required but no available authenticator supported it",
+        code: "ERROR_AUTHENTICATOR_MISSING_USER_VERIFICATION_SUPPORT",
+        cause: error
+      });
+    }
+  } else if (error.name === "InvalidStateError") {
+    return new WebAuthnError({
+      message: "The authenticator was previously registered",
+      code: "ERROR_AUTHENTICATOR_PREVIOUSLY_REGISTERED",
+      cause: error
+    });
+  } else if (error.name === "NotAllowedError") {
+    return new WebAuthnError({
+      message: error.message,
+      code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+      cause: error
+    });
+  } else if (error.name === "NotSupportedError") {
+    const validPubKeyCredParams = publicKey.pubKeyCredParams.filter((param) => param.type === "public-key");
+    if (validPubKeyCredParams.length === 0) {
+      return new WebAuthnError({
+        message: 'No entry in pubKeyCredParams was of type "public-key"',
+        code: "ERROR_MALFORMED_PUBKEYCREDPARAMS",
+        cause: error
+      });
+    }
+    return new WebAuthnError({
+      message: "No available authenticator supported any of the specified pubKeyCredParams algorithms",
+      code: "ERROR_AUTHENTICATOR_NO_SUPPORTED_PUBKEYCREDPARAMS_ALG",
+      cause: error
+    });
+  } else if (error.name === "SecurityError") {
+    const effectiveDomain = globalThis.location.hostname;
+    if (!isValidDomain(effectiveDomain)) {
+      return new WebAuthnError({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: error
+      });
+    } else if (publicKey.rp.id !== effectiveDomain) {
+      return new WebAuthnError({
+        message: `The RP ID "${publicKey.rp.id}" is invalid for this domain`,
+        code: "ERROR_INVALID_RP_ID",
+        cause: error
+      });
+    }
+  } else if (error.name === "TypeError") {
+    if (publicKey.user.id.byteLength < 1 || publicKey.user.id.byteLength > 64) {
+      return new WebAuthnError({
+        message: "User ID was not between 1 and 64 characters",
+        code: "ERROR_INVALID_USER_ID_LENGTH",
+        cause: error
+      });
+    }
+  } else if (error.name === "UnknownError") {
+    return new WebAuthnError({
+      message: "The authenticator was unable to process the specified options, or could not create a new credential",
+      code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+      cause: error
+    });
+  }
+  return error;
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/webAuthnAbortService.js
+var BaseWebAuthnAbortService = class {
+  constructor() {
+    Object.defineProperty(this, "controller", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+  }
+  createNewAbortSignal() {
+    if (this.controller) {
+      const abortError = new Error("Cancelling existing WebAuthn API call for new one");
+      abortError.name = "AbortError";
+      this.controller.abort(abortError);
+    }
+    const newController = new AbortController();
+    this.controller = newController;
+    return newController.signal;
+  }
+  cancelCeremony() {
+    if (this.controller) {
+      const abortError = new Error("Manually cancelling existing WebAuthn API call");
+      abortError.name = "AbortError";
+      this.controller.abort(abortError);
+      this.controller = void 0;
+    }
+  }
+};
+var WebAuthnAbortService = new BaseWebAuthnAbortService();
+
+// node_modules/@simplewebauthn/browser/esm/helpers/toAuthenticatorAttachment.js
+var attachments = ["cross-platform", "platform"];
+function toAuthenticatorAttachment(attachment) {
+  if (!attachment) {
+    return;
+  }
+  if (attachments.indexOf(attachment) < 0) {
+    return;
+  }
+  return attachment;
+}
+
+// node_modules/@simplewebauthn/browser/esm/methods/startRegistration.js
+async function startRegistration(options) {
+  if (!options.optionsJSON && options.challenge) {
+    console.warn("startRegistration() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information.");
+    options = { optionsJSON: options };
+  }
+  const { optionsJSON, useAutoRegister = false } = options;
+  if (!browserSupportsWebAuthn()) {
+    throw new Error("WebAuthn is not supported in this browser");
+  }
+  const publicKey = {
+    ...optionsJSON,
+    challenge: base64URLStringToBuffer(optionsJSON.challenge),
+    user: {
+      ...optionsJSON.user,
+      id: base64URLStringToBuffer(optionsJSON.user.id)
+    },
+    excludeCredentials: optionsJSON.excludeCredentials?.map(toPublicKeyCredentialDescriptor)
+  };
+  const createOptions = {};
+  if (useAutoRegister) {
+    createOptions.mediation = "conditional";
+  }
+  createOptions.publicKey = publicKey;
+  createOptions.signal = WebAuthnAbortService.createNewAbortSignal();
+  let credential;
+  try {
+    credential = await navigator.credentials.create(createOptions);
+  } catch (err) {
+    throw identifyRegistrationError({ error: err, options: createOptions });
+  }
+  if (!credential) {
+    throw new Error("Registration was not completed");
+  }
+  const { id, rawId, response, type } = credential;
+  let transports = void 0;
+  if (typeof response.getTransports === "function") {
+    transports = response.getTransports();
+  }
+  let responsePublicKeyAlgorithm = void 0;
+  if (typeof response.getPublicKeyAlgorithm === "function") {
+    try {
+      responsePublicKeyAlgorithm = response.getPublicKeyAlgorithm();
+    } catch (error) {
+      warnOnBrokenImplementation("getPublicKeyAlgorithm()", error);
+    }
+  }
+  let responsePublicKey = void 0;
+  if (typeof response.getPublicKey === "function") {
+    try {
+      const _publicKey = response.getPublicKey();
+      if (_publicKey !== null) {
+        responsePublicKey = bufferToBase64URLString(_publicKey);
+      }
+    } catch (error) {
+      warnOnBrokenImplementation("getPublicKey()", error);
+    }
+  }
+  let responseAuthenticatorData;
+  if (typeof response.getAuthenticatorData === "function") {
+    try {
+      responseAuthenticatorData = bufferToBase64URLString(response.getAuthenticatorData());
+    } catch (error) {
+      warnOnBrokenImplementation("getAuthenticatorData()", error);
+    }
+  }
+  return {
+    id,
+    rawId: bufferToBase64URLString(rawId),
+    response: {
+      attestationObject: bufferToBase64URLString(response.attestationObject),
+      clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
+      transports,
+      publicKeyAlgorithm: responsePublicKeyAlgorithm,
+      publicKey: responsePublicKey,
+      authenticatorData: responseAuthenticatorData
+    },
+    type,
+    clientExtensionResults: credential.getClientExtensionResults(),
+    authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment)
+  };
+}
+function warnOnBrokenImplementation(methodName, cause) {
+  console.warn(`The browser extension that intercepted this WebAuthn API call incorrectly implemented ${methodName}. You should report this error to them.
+`, cause);
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/browserSupportsWebAuthnAutofill.js
+function browserSupportsWebAuthnAutofill() {
+  if (!browserSupportsWebAuthn()) {
+    return _browserSupportsWebAuthnAutofillInternals.stubThis(new Promise((resolve) => resolve(false)));
+  }
+  const globalPublicKeyCredential = globalThis.PublicKeyCredential;
+  if (globalPublicKeyCredential?.isConditionalMediationAvailable === void 0) {
+    return _browserSupportsWebAuthnAutofillInternals.stubThis(new Promise((resolve) => resolve(false)));
+  }
+  return _browserSupportsWebAuthnAutofillInternals.stubThis(globalPublicKeyCredential.isConditionalMediationAvailable());
+}
+var _browserSupportsWebAuthnAutofillInternals = {
+  stubThis: (value) => value
+};
+
+// node_modules/@simplewebauthn/browser/esm/helpers/identifyAuthenticationError.js
+function identifyAuthenticationError({ error, options }) {
+  const { publicKey } = options;
+  if (!publicKey) {
+    throw Error("options was missing required publicKey property");
+  }
+  if (error.name === "AbortError") {
+    if (options.signal instanceof AbortSignal) {
+      return new WebAuthnError({
+        message: "Authentication ceremony was sent an abort signal",
+        code: "ERROR_CEREMONY_ABORTED",
+        cause: error
+      });
+    }
+  } else if (error.name === "NotAllowedError") {
+    return new WebAuthnError({
+      message: error.message,
+      code: "ERROR_PASSTHROUGH_SEE_CAUSE_PROPERTY",
+      cause: error
+    });
+  } else if (error.name === "SecurityError") {
+    const effectiveDomain = globalThis.location.hostname;
+    if (!isValidDomain(effectiveDomain)) {
+      return new WebAuthnError({
+        message: `${globalThis.location.hostname} is an invalid domain`,
+        code: "ERROR_INVALID_DOMAIN",
+        cause: error
+      });
+    } else if (publicKey.rpId !== effectiveDomain) {
+      return new WebAuthnError({
+        message: `The RP ID "${publicKey.rpId}" is invalid for this domain`,
+        code: "ERROR_INVALID_RP_ID",
+        cause: error
+      });
+    }
+  } else if (error.name === "UnknownError") {
+    return new WebAuthnError({
+      message: "The authenticator was unable to process the specified options, or could not create a new assertion signature",
+      code: "ERROR_AUTHENTICATOR_GENERAL_ERROR",
+      cause: error
+    });
+  }
+  return error;
+}
+
+// node_modules/@simplewebauthn/browser/esm/methods/startAuthentication.js
+async function startAuthentication(options) {
+  if (!options.optionsJSON && options.challenge) {
+    console.warn("startAuthentication() was not called correctly. It will try to continue with the provided options, but this call should be refactored to use the expected call structure instead. See https://simplewebauthn.dev/docs/packages/browser#typeerror-cannot-read-properties-of-undefined-reading-challenge for more information.");
+    options = { optionsJSON: options };
+  }
+  const { optionsJSON, useBrowserAutofill = false, verifyBrowserAutofillInput = true } = options;
+  if (!browserSupportsWebAuthn()) {
+    throw new Error("WebAuthn is not supported in this browser");
+  }
+  let allowCredentials;
+  if (optionsJSON.allowCredentials?.length !== 0) {
+    allowCredentials = optionsJSON.allowCredentials?.map(toPublicKeyCredentialDescriptor);
+  }
+  const publicKey = {
+    ...optionsJSON,
+    challenge: base64URLStringToBuffer(optionsJSON.challenge),
+    allowCredentials
+  };
+  const getOptions = {};
+  if (useBrowserAutofill) {
+    if (!await browserSupportsWebAuthnAutofill()) {
+      throw Error("Browser does not support WebAuthn autofill");
+    }
+    const eligibleInputs = document.querySelectorAll("input[autocomplete$='webauthn']");
+    if (eligibleInputs.length < 1 && verifyBrowserAutofillInput) {
+      throw Error('No <input> with "webauthn" as the only or last value in its `autocomplete` attribute was detected');
+    }
+    getOptions.mediation = "conditional";
+    publicKey.allowCredentials = [];
+  }
+  getOptions.publicKey = publicKey;
+  getOptions.signal = WebAuthnAbortService.createNewAbortSignal();
+  let credential;
+  try {
+    credential = await navigator.credentials.get(getOptions);
+  } catch (err) {
+    throw identifyAuthenticationError({ error: err, options: getOptions });
+  }
+  if (!credential) {
+    throw new Error("Authentication was not completed");
+  }
+  const { id, rawId, response, type } = credential;
+  let userHandle = void 0;
+  if (response.userHandle) {
+    userHandle = bufferToBase64URLString(response.userHandle);
+  }
+  return {
+    id,
+    rawId: bufferToBase64URLString(rawId),
+    response: {
+      authenticatorData: bufferToBase64URLString(response.authenticatorData),
+      clientDataJSON: bufferToBase64URLString(response.clientDataJSON),
+      signature: bufferToBase64URLString(response.signature),
+      userHandle
+    },
+    type,
+    clientExtensionResults: credential.getClientExtensionResults(),
+    authenticatorAttachment: toAuthenticatorAttachment(credential.authenticatorAttachment)
+  };
+}
+
+// node_modules/@simplewebauthn/browser/esm/helpers/platformAuthenticatorIsAvailable.js
+function platformAuthenticatorIsAvailable() {
+  if (!browserSupportsWebAuthn()) {
+    return new Promise((resolve) => resolve(false));
+  }
+  return PublicKeyCredential.isUserVerifyingPlatformAuthenticatorAvailable();
+}
+export {
+  WebAuthnAbortService,
+  WebAuthnError,
+  _browserSupportsWebAuthnAutofillInternals,
+  _browserSupportsWebAuthnInternals,
+  base64URLStringToBuffer,
+  browserSupportsWebAuthn,
+  browserSupportsWebAuthnAutofill,
+  bufferToBase64URLString,
+  platformAuthenticatorIsAvailable,
+  startAuthentication,
+  startRegistration
+};
+//# sourceMappingURL=@simplewebauthn_browser.js.map

web/node_modules/.vite/deps/@xterm_addon-fit.js

@@ -0,0 +1,41 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@xterm/addon-fit/lib/addon-fit.js
+var require_addon_fit = __commonJS({
+  "node_modules/@xterm/addon-fit/lib/addon-fit.js"(exports, module) {
+    !(function(e, t) {
+      "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.FitAddon = t() : e.FitAddon = t();
+    })(self, (() => (() => {
+      "use strict";
+      var e = {};
+      return (() => {
+        var t = e;
+        Object.defineProperty(t, "__esModule", { value: true }), t.FitAddon = void 0, t.FitAddon = class {
+          activate(e2) {
+            this._terminal = e2;
+          }
+          dispose() {
+          }
+          fit() {
+            const e2 = this.proposeDimensions();
+            if (!e2 || !this._terminal || isNaN(e2.cols) || isNaN(e2.rows)) return;
+            const t2 = this._terminal._core;
+            this._terminal.rows === e2.rows && this._terminal.cols === e2.cols || (t2._renderService.clear(), this._terminal.resize(e2.cols, e2.rows));
+          }
+          proposeDimensions() {
+            if (!this._terminal) return;
+            if (!this._terminal.element || !this._terminal.element.parentElement) return;
+            const e2 = this._terminal._core, t2 = e2._renderService.dimensions;
+            if (0 === t2.css.cell.width || 0 === t2.css.cell.height) return;
+            const r = 0 === this._terminal.options.scrollback ? 0 : e2.viewport.scrollBarWidth, i = window.getComputedStyle(this._terminal.element.parentElement), o = parseInt(i.getPropertyValue("height")), s = Math.max(0, parseInt(i.getPropertyValue("width"))), n = window.getComputedStyle(this._terminal.element), l = o - (parseInt(n.getPropertyValue("padding-top")) + parseInt(n.getPropertyValue("padding-bottom"))), a = s - (parseInt(n.getPropertyValue("padding-right")) + parseInt(n.getPropertyValue("padding-left"))) - r;
+            return { cols: Math.max(2, Math.floor(a / t2.css.cell.width)), rows: Math.max(1, Math.floor(l / t2.css.cell.height)) };
+          }
+        };
+      })(), e;
+    })()));
+  }
+});
+export default require_addon_fit();
+//# sourceMappingURL=@xterm_addon-fit.js.map

web/node_modules/.vite/deps/@xterm_addon-fit.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["webpack://FitAddon/webpack/universalModuleDefinition", "webpack://FitAddon/src/FitAddon.ts"],
+  "sourcesContent": ["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"FitAddon\"] = factory();\n\telse\n\t\troot[\"FitAddon\"] = factory();\n})(self, () => {\nreturn ", "/**\n * Copyright (c) 2017 The xterm.js authors. All rights reserved.\n * @license MIT\n */\n\nimport type { Terminal, ITerminalAddon } from '@xterm/xterm';\nimport type { FitAddon as IFitApi } from '@xterm/addon-fit';\nimport { IRenderDimensions } from 'browser/renderer/shared/Types';\n\ninterface ITerminalDimensions {\n  /**\n   * The number of rows in the terminal.\n   */\n  rows: number;\n\n  /**\n   * The number of columns in the terminal.\n   */\n  cols: number;\n}\n\nconst MINIMUM_COLS = 2;\nconst MINIMUM_ROWS = 1;\n\nexport class FitAddon implements ITerminalAddon , IFitApi {\n  private _terminal: Terminal | undefined;\n\n  public activate(terminal: Terminal): void {\n    this._terminal = terminal;\n  }\n\n  public dispose(): void {}\n\n  public fit(): void {\n    const dims = this.proposeDimensions();\n    if (!dims || !this._terminal || isNaN(dims.cols) || isNaN(dims.rows)) {\n      return;\n    }\n\n    // TODO: Remove reliance on private API\n    const core = (this._terminal as any)._core;\n\n    // Force a full render\n    if (this._terminal.rows !== dims.rows || this._terminal.cols !== dims.cols) {\n      core._renderService.clear();\n      this._terminal.resize(dims.cols, dims.rows);\n    }\n  }\n\n  public proposeDimensions(): ITerminalDimensions | undefined {\n    if (!this._terminal) {\n      return undefined;\n    }\n\n    if (!this._terminal.element || !this._terminal.element.parentElement) {\n      return undefined;\n    }\n\n    // TODO: Remove reliance on private API\n    const core = (this._terminal as any)._core;\n    const dims: IRenderDimensions = core._renderService.dimensions;\n\n    if (dims.css.cell.width === 0 || dims.css.cell.height === 0) {\n      return undefined;\n    }\n\n    const scrollbarWidth = this._terminal.options.scrollback === 0 ?\n      0 : core.viewport.scrollBarWidth;\n\n    const parentElementStyle = window.getComputedStyle(this._terminal.element.parentElement);\n    const parentElementHeight = parseInt(parentElementStyle.getPropertyValue('height'));\n    const parentElementWidth = Math.max(0, parseInt(parentElementStyle.getPropertyValue('width')));\n    const elementStyle = window.getComputedStyle(this._terminal.element);\n    const elementPadding = {\n      top: parseInt(elementStyle.getPropertyValue('padding-top')),\n      bottom: parseInt(elementStyle.getPropertyValue('padding-bottom')),\n      right: parseInt(elementStyle.getPropertyValue('padding-right')),\n      left: parseInt(elementStyle.getPropertyValue('padding-left'))\n    };\n    const elementPaddingVer = elementPadding.top + elementPadding.bottom;\n    const elementPaddingHor = elementPadding.right + elementPadding.left;\n    const availableHeight = parentElementHeight - elementPaddingVer;\n    const availableWidth = parentElementWidth - elementPaddingHor - scrollbarWidth;\n    const geometry = {\n      cols: Math.max(MINIMUM_COLS, Math.floor(availableWidth / dims.css.cell.width)),\n      rows: Math.max(MINIMUM_ROWS, Math.floor(availableHeight / dims.css.cell.height))\n    };\n    return geometry;\n  }\n}\n"],
+  "mappings": ";;;;;;;MAAA,SAA2CA,GAAMC,GAAAA;AAC1B,kBAAA,OAAZC,WAA0C,YAAA,OAAXC,SACxCA,OAAOD,UAAUD,EAAAA,IACQ,cAAA,OAAXG,UAAyBA,OAAOC,MAC9CD,OAAO,CAAA,GAAIH,CAAAA,IACe,YAAA,OAAZC,UACdA,QAAkB,WAAID,EAAAA,IAEtBD,EAAe,WAAIC,EAAAA;IACpB,GAAEK,OAAM,OAAA,MAAA;AAAA;AAAA,UAAA,IAAA,CAAA;AAAA,cAAA,MAAA;AAAA,YAAA,IAAA;AAAA,eAAA,eAAA,GAAA,cAAA,EAAA,OAAA,KAAA,CAAA,GAAA,EAAA,WAAA,QCeT,EAAA,WAAA,MAAA;UAGS,SAASC,IAAAA;AACdC,iBAAKC,YAAYF;UACnB;UAEO,UAAAG;UAAiB;UAEjB,MAAAC;AACL,kBAAMC,KAAOJ,KAAKK,kBAAAA;AAClB,gBAAA,CAAKD,MAAAA,CAASJ,KAAKC,aAAaK,MAAMF,GAAKG,IAAAA,KAASD,MAAMF,GAAKI,IAAAA,EAC7D;AAIF,kBAAMC,KAAQT,KAAKC,UAAkBS;AAGjCV,iBAAKC,UAAUO,SAASJ,GAAKI,QAAQR,KAAKC,UAAUM,SAASH,GAAKG,SACpEE,GAAKE,eAAeC,MAAAA,GACpBZ,KAAKC,UAAUY,OAAOT,GAAKG,MAAMH,GAAKI,IAAAA;UAE1C;UAEO,oBAAAH;AACL,gBAAA,CAAKL,KAAKC,UACR;AAGF,gBAAA,CAAKD,KAAKC,UAAUa,WAAAA,CAAYd,KAAKC,UAAUa,QAAQC,cACrD;AAIF,kBAAMN,KAAQT,KAAKC,UAAkBS,OAC/BN,KAA0BK,GAAKE,eAAeK;AAEpD,gBAA4B,MAAxBZ,GAAKa,IAAIC,KAAKC,SAAwC,MAAzBf,GAAKa,IAAIC,KAAKE,OAC7C;AAGF,kBAAMC,IAAuD,MAAtCrB,KAAKC,UAAUqB,QAAQC,aAC5C,IAAId,GAAKe,SAASC,gBAEdC,IAAqBC,OAAOC,iBAAiB5B,KAAKC,UAAUa,QAAQC,aAAAA,GACpEc,IAAsBC,SAASJ,EAAmBK,iBAAiB,QAAA,CAAA,GACnEC,IAAqBC,KAAKC,IAAI,GAAGJ,SAASJ,EAAmBK,iBAAiB,OAAA,CAAA,CAAA,GAC9EI,IAAeR,OAAOC,iBAAiB5B,KAAKC,UAAUa,OAAAA,GAStDsB,IAAkBP,KAPjBC,SAASK,EAAaJ,iBAAiB,aAAA,CAAA,IACpCD,SAASK,EAAaJ,iBAAiB,gBAAA,CAAA,IAO3CM,IAAiBL,KANdF,SAASK,EAAaJ,iBAAiB,eAAA,CAAA,IACxCD,SAASK,EAAaJ,iBAAiB,cAAA,CAAA,KAKiBV;AAKhE,mBAJiB,EACfd,MAAM0B,KAAKC,IA/DI,GA+DcD,KAAKK,MAAMD,IAAiBjC,GAAKa,IAAIC,KAAKC,KAAAA,CAAAA,GACvEX,MAAMyB,KAAKC,IA/DI,GA+DcD,KAAKK,MAAMF,IAAkBhC,GAAKa,IAAIC,KAAKE,MAAAA,CAAAA,EAAAA;UAG5E;QAAA;MAAA,GAAA,GAAA;IAAA,GAAA,EAAA;;;",
+  "names": ["root", "factory", "exports", "module", "define", "amd", "self", "terminal", "this", "_terminal", "dispose", "fit", "dims", "proposeDimensions", "isNaN", "cols", "rows", "core", "_core", "_renderService", "clear", "resize", "element", "parentElement", "dimensions", "css", "cell", "width", "height", "scrollbarWidth", "options", "scrollback", "viewport", "scrollBarWidth", "parentElementStyle", "window", "getComputedStyle", "parentElementHeight", "parseInt", "getPropertyValue", "parentElementWidth", "Math", "max", "elementStyle", "availableHeight", "availableWidth", "floor"]
+}

web/node_modules/.vite/deps/@xterm_addon-search.js

@@ -0,0 +1,314 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@xterm/addon-search/lib/addon-search.js
+var require_addon_search = __commonJS({
+  "node_modules/@xterm/addon-search/lib/addon-search.js"(exports, module) {
+    !(function(e, t) {
+      "object" == typeof exports && "object" == typeof module ? module.exports = t() : "function" == typeof define && define.amd ? define([], t) : "object" == typeof exports ? exports.SearchAddon = t() : e.SearchAddon = t();
+    })(self, (() => (() => {
+      "use strict";
+      var e = { 345: (e2, t2) => {
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.runAndSubscribe = t2.forwardEvent = t2.EventEmitter = void 0, t2.EventEmitter = class {
+          constructor() {
+            this._listeners = [], this._disposed = false;
+          }
+          get event() {
+            return this._event || (this._event = (e3) => (this._listeners.push(e3), { dispose: () => {
+              if (!this._disposed) {
+                for (let t3 = 0; t3 < this._listeners.length; t3++) if (this._listeners[t3] === e3) return void this._listeners.splice(t3, 1);
+              }
+            } })), this._event;
+          }
+          fire(e3, t3) {
+            const i2 = [];
+            for (let e4 = 0; e4 < this._listeners.length; e4++) i2.push(this._listeners[e4]);
+            for (let s2 = 0; s2 < i2.length; s2++) i2[s2].call(void 0, e3, t3);
+          }
+          dispose() {
+            this.clearListeners(), this._disposed = true;
+          }
+          clearListeners() {
+            this._listeners && (this._listeners.length = 0);
+          }
+        }, t2.forwardEvent = function(e3, t3) {
+          return e3(((e4) => t3.fire(e4)));
+        }, t2.runAndSubscribe = function(e3, t3) {
+          return t3(void 0), e3(((e4) => t3(e4)));
+        };
+      }, 859: (e2, t2) => {
+        function i2(e3) {
+          for (const t3 of e3) t3.dispose();
+          e3.length = 0;
+        }
+        Object.defineProperty(t2, "__esModule", { value: true }), t2.getDisposeArrayDisposable = t2.disposeArray = t2.toDisposable = t2.MutableDisposable = t2.Disposable = void 0, t2.Disposable = class {
+          constructor() {
+            this._disposables = [], this._isDisposed = false;
+          }
+          dispose() {
+            this._isDisposed = true;
+            for (const e3 of this._disposables) e3.dispose();
+            this._disposables.length = 0;
+          }
+          register(e3) {
+            return this._disposables.push(e3), e3;
+          }
+          unregister(e3) {
+            const t3 = this._disposables.indexOf(e3);
+            -1 !== t3 && this._disposables.splice(t3, 1);
+          }
+        }, t2.MutableDisposable = class {
+          constructor() {
+            this._isDisposed = false;
+          }
+          get value() {
+            return this._isDisposed ? void 0 : this._value;
+          }
+          set value(e3) {
+            this._isDisposed || e3 === this._value || (this._value?.dispose(), this._value = e3);
+          }
+          clear() {
+            this.value = void 0;
+          }
+          dispose() {
+            this._isDisposed = true, this._value?.dispose(), this._value = void 0;
+          }
+        }, t2.toDisposable = function(e3) {
+          return { dispose: e3 };
+        }, t2.disposeArray = i2, t2.getDisposeArrayDisposable = function(e3) {
+          return { dispose: () => i2(e3) };
+        };
+      } }, t = {};
+      function i(s2) {
+        var r = t[s2];
+        if (void 0 !== r) return r.exports;
+        var o = t[s2] = { exports: {} };
+        return e[s2](o, o.exports, i), o.exports;
+      }
+      var s = {};
+      return (() => {
+        var e2 = s;
+        Object.defineProperty(e2, "__esModule", { value: true }), e2.SearchAddon = void 0;
+        const t2 = i(345), r = i(859), o = " ~!@#$%^&*()+`-=[]{}|\\;:\"',./<>?";
+        class n extends r.Disposable {
+          constructor(e3) {
+            super(), this._highlightedLines = /* @__PURE__ */ new Set(), this._highlightDecorations = [], this._selectedDecoration = this.register(new r.MutableDisposable()), this._linesCacheTimeoutId = 0, this._linesCacheDisposables = new r.MutableDisposable(), this._onDidChangeResults = this.register(new t2.EventEmitter()), this.onDidChangeResults = this._onDidChangeResults.event, this._highlightLimit = e3?.highlightLimit ?? 1e3;
+          }
+          activate(e3) {
+            this._terminal = e3, this.register(this._terminal.onWriteParsed((() => this._updateMatches()))), this.register(this._terminal.onResize((() => this._updateMatches()))), this.register((0, r.toDisposable)((() => this.clearDecorations())));
+          }
+          _updateMatches() {
+            this._highlightTimeout && window.clearTimeout(this._highlightTimeout), this._cachedSearchTerm && this._lastSearchOptions?.decorations && (this._highlightTimeout = setTimeout((() => {
+              const e3 = this._cachedSearchTerm;
+              this._cachedSearchTerm = void 0, this.findPrevious(e3, { ...this._lastSearchOptions, incremental: true, noScroll: true });
+            }), 200));
+          }
+          clearDecorations(e3) {
+            this._selectedDecoration.clear(), (0, r.disposeArray)(this._highlightDecorations), this._highlightDecorations = [], this._highlightedLines.clear(), e3 || (this._cachedSearchTerm = void 0);
+          }
+          clearActiveDecoration() {
+            this._selectedDecoration.clear();
+          }
+          findNext(e3, t3) {
+            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
+            const i2 = !this._lastSearchOptions || this._didOptionsChange(this._lastSearchOptions, t3);
+            this._lastSearchOptions = t3, t3?.decorations && (void 0 === this._cachedSearchTerm || e3 !== this._cachedSearchTerm || i2) && this._highlightAllMatches(e3, t3);
+            const s2 = this._findNextAndSelect(e3, t3);
+            return this._fireResults(t3), this._cachedSearchTerm = e3, s2;
+          }
+          _highlightAllMatches(e3, t3) {
+            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
+            if (!e3 || 0 === e3.length) return void this.clearDecorations();
+            t3 = t3 || {}, this.clearDecorations(true);
+            const i2 = [];
+            let s2, r2 = this._find(e3, 0, 0, t3);
+            for (; r2 && (s2?.row !== r2.row || s2?.col !== r2.col) && !(i2.length >= this._highlightLimit); ) s2 = r2, i2.push(s2), r2 = this._find(e3, s2.col + s2.term.length >= this._terminal.cols ? s2.row + 1 : s2.row, s2.col + s2.term.length >= this._terminal.cols ? 0 : s2.col + 1, t3);
+            for (const e4 of i2) {
+              const i3 = this._createResultDecoration(e4, t3.decorations);
+              i3 && (this._highlightedLines.add(i3.marker.line), this._highlightDecorations.push({ decoration: i3, match: e4, dispose() {
+                i3.dispose();
+              } }));
+            }
+          }
+          _find(e3, t3, i2, s2) {
+            if (!this._terminal || !e3 || 0 === e3.length) return this._terminal?.clearSelection(), void this.clearDecorations();
+            if (i2 > this._terminal.cols) throw new Error(`Invalid col: ${i2} to search in terminal of ${this._terminal.cols} cols`);
+            let r2;
+            this._initLinesCache();
+            const o2 = { startRow: t3, startCol: i2 };
+            if (r2 = this._findInLine(e3, o2, s2), !r2) for (let i3 = t3 + 1; i3 < this._terminal.buffer.active.baseY + this._terminal.rows && (o2.startRow = i3, o2.startCol = 0, r2 = this._findInLine(e3, o2, s2), !r2); i3++) ;
+            return r2;
+          }
+          _findNextAndSelect(e3, t3) {
+            if (!this._terminal || !e3 || 0 === e3.length) return this._terminal?.clearSelection(), this.clearDecorations(), false;
+            const i2 = this._terminal.getSelectionPosition();
+            this._terminal.clearSelection();
+            let s2 = 0, r2 = 0;
+            i2 && (this._cachedSearchTerm === e3 ? (s2 = i2.end.x, r2 = i2.end.y) : (s2 = i2.start.x, r2 = i2.start.y)), this._initLinesCache();
+            const o2 = { startRow: r2, startCol: s2 };
+            let n2 = this._findInLine(e3, o2, t3);
+            if (!n2) for (let i3 = r2 + 1; i3 < this._terminal.buffer.active.baseY + this._terminal.rows && (o2.startRow = i3, o2.startCol = 0, n2 = this._findInLine(e3, o2, t3), !n2); i3++) ;
+            if (!n2 && 0 !== r2) for (let i3 = 0; i3 < r2 && (o2.startRow = i3, o2.startCol = 0, n2 = this._findInLine(e3, o2, t3), !n2); i3++) ;
+            return !n2 && i2 && (o2.startRow = i2.start.y, o2.startCol = 0, n2 = this._findInLine(e3, o2, t3)), this._selectResult(n2, t3?.decorations, t3?.noScroll);
+          }
+          findPrevious(e3, t3) {
+            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
+            const i2 = !this._lastSearchOptions || this._didOptionsChange(this._lastSearchOptions, t3);
+            this._lastSearchOptions = t3, t3?.decorations && (void 0 === this._cachedSearchTerm || e3 !== this._cachedSearchTerm || i2) && this._highlightAllMatches(e3, t3);
+            const s2 = this._findPreviousAndSelect(e3, t3);
+            return this._fireResults(t3), this._cachedSearchTerm = e3, s2;
+          }
+          _didOptionsChange(e3, t3) {
+            return !!t3 && (e3.caseSensitive !== t3.caseSensitive || e3.regex !== t3.regex || e3.wholeWord !== t3.wholeWord);
+          }
+          _fireResults(e3) {
+            if (e3?.decorations) {
+              let e4 = -1;
+              if (this._selectedDecoration.value) {
+                const t3 = this._selectedDecoration.value.match;
+                for (let i2 = 0; i2 < this._highlightDecorations.length; i2++) {
+                  const s2 = this._highlightDecorations[i2].match;
+                  if (s2.row === t3.row && s2.col === t3.col && s2.size === t3.size) {
+                    e4 = i2;
+                    break;
+                  }
+                }
+              }
+              this._onDidChangeResults.fire({ resultIndex: e4, resultCount: this._highlightDecorations.length });
+            }
+          }
+          _findPreviousAndSelect(e3, t3) {
+            if (!this._terminal) throw new Error("Cannot use addon until it has been loaded");
+            if (!this._terminal || !e3 || 0 === e3.length) return this._terminal?.clearSelection(), this.clearDecorations(), false;
+            const i2 = this._terminal.getSelectionPosition();
+            this._terminal.clearSelection();
+            let s2 = this._terminal.buffer.active.baseY + this._terminal.rows - 1, r2 = this._terminal.cols;
+            const o2 = true;
+            this._initLinesCache();
+            const n2 = { startRow: s2, startCol: r2 };
+            let h;
+            if (i2 && (n2.startRow = s2 = i2.start.y, n2.startCol = r2 = i2.start.x, this._cachedSearchTerm !== e3 && (h = this._findInLine(e3, n2, t3, false), h || (n2.startRow = s2 = i2.end.y, n2.startCol = r2 = i2.end.x))), h || (h = this._findInLine(e3, n2, t3, o2)), !h) {
+              n2.startCol = Math.max(n2.startCol, this._terminal.cols);
+              for (let i3 = s2 - 1; i3 >= 0 && (n2.startRow = i3, h = this._findInLine(e3, n2, t3, o2), !h); i3--) ;
+            }
+            if (!h && s2 !== this._terminal.buffer.active.baseY + this._terminal.rows - 1) for (let i3 = this._terminal.buffer.active.baseY + this._terminal.rows - 1; i3 >= s2 && (n2.startRow = i3, h = this._findInLine(e3, n2, t3, o2), !h); i3--) ;
+            return this._selectResult(h, t3?.decorations, t3?.noScroll);
+          }
+          _initLinesCache() {
+            const e3 = this._terminal;
+            this._linesCache || (this._linesCache = new Array(e3.buffer.active.length), this._linesCacheDisposables.value = (0, r.getDisposeArrayDisposable)([e3.onLineFeed((() => this._destroyLinesCache())), e3.onCursorMove((() => this._destroyLinesCache())), e3.onResize((() => this._destroyLinesCache()))])), window.clearTimeout(this._linesCacheTimeoutId), this._linesCacheTimeoutId = window.setTimeout((() => this._destroyLinesCache()), 15e3);
+          }
+          _destroyLinesCache() {
+            this._linesCache = void 0, this._linesCacheDisposables.clear(), this._linesCacheTimeoutId && (window.clearTimeout(this._linesCacheTimeoutId), this._linesCacheTimeoutId = 0);
+          }
+          _isWholeWord(e3, t3, i2) {
+            return (0 === e3 || o.includes(t3[e3 - 1])) && (e3 + i2.length === t3.length || o.includes(t3[e3 + i2.length]));
+          }
+          _findInLine(e3, t3, i2 = {}, s2 = false) {
+            const r2 = this._terminal, o2 = t3.startRow, n2 = t3.startCol, h = r2.buffer.active.getLine(o2);
+            if (h?.isWrapped) return s2 ? void (t3.startCol += r2.cols) : (t3.startRow--, t3.startCol += r2.cols, this._findInLine(e3, t3, i2));
+            let a = this._linesCache?.[o2];
+            a || (a = this._translateBufferLineToStringWithWrap(o2, true), this._linesCache && (this._linesCache[o2] = a));
+            const [l, c] = a, d = this._bufferColsToStringOffset(o2, n2), _ = i2.caseSensitive ? e3 : e3.toLowerCase(), u = i2.caseSensitive ? l : l.toLowerCase();
+            let f = -1;
+            if (i2.regex) {
+              const t4 = RegExp(_, "g");
+              let i3;
+              if (s2) for (; i3 = t4.exec(u.slice(0, d)); ) f = t4.lastIndex - i3[0].length, e3 = i3[0], t4.lastIndex -= e3.length - 1;
+              else i3 = t4.exec(u.slice(d)), i3 && i3[0].length > 0 && (f = d + (t4.lastIndex - i3[0].length), e3 = i3[0]);
+            } else s2 ? d - _.length >= 0 && (f = u.lastIndexOf(_, d - _.length)) : f = u.indexOf(_, d);
+            if (f >= 0) {
+              if (i2.wholeWord && !this._isWholeWord(f, u, e3)) return;
+              let t4 = 0;
+              for (; t4 < c.length - 1 && f >= c[t4 + 1]; ) t4++;
+              let s3 = t4;
+              for (; s3 < c.length - 1 && f + e3.length >= c[s3 + 1]; ) s3++;
+              const n3 = f - c[t4], h2 = f + e3.length - c[s3], a2 = this._stringLengthToBufferSize(o2 + t4, n3);
+              return { term: e3, col: a2, row: o2 + t4, size: this._stringLengthToBufferSize(o2 + s3, h2) - a2 + r2.cols * (s3 - t4) };
+            }
+          }
+          _stringLengthToBufferSize(e3, t3) {
+            const i2 = this._terminal.buffer.active.getLine(e3);
+            if (!i2) return 0;
+            for (let e4 = 0; e4 < t3; e4++) {
+              const s2 = i2.getCell(e4);
+              if (!s2) break;
+              const r2 = s2.getChars();
+              r2.length > 1 && (t3 -= r2.length - 1);
+              const o2 = i2.getCell(e4 + 1);
+              o2 && 0 === o2.getWidth() && t3++;
+            }
+            return t3;
+          }
+          _bufferColsToStringOffset(e3, t3) {
+            const i2 = this._terminal;
+            let s2 = e3, r2 = 0, o2 = i2.buffer.active.getLine(s2);
+            for (; t3 > 0 && o2; ) {
+              for (let e4 = 0; e4 < t3 && e4 < i2.cols; e4++) {
+                const t4 = o2.getCell(e4);
+                if (!t4) break;
+                t4.getWidth() && (r2 += 0 === t4.getCode() ? 1 : t4.getChars().length);
+              }
+              if (s2++, o2 = i2.buffer.active.getLine(s2), o2 && !o2.isWrapped) break;
+              t3 -= i2.cols;
+            }
+            return r2;
+          }
+          _translateBufferLineToStringWithWrap(e3, t3) {
+            const i2 = this._terminal, s2 = [], r2 = [0];
+            let o2 = i2.buffer.active.getLine(e3);
+            for (; o2; ) {
+              const n2 = i2.buffer.active.getLine(e3 + 1), h = !!n2 && n2.isWrapped;
+              let a = o2.translateToString(!h && t3);
+              if (h && n2) {
+                const e4 = o2.getCell(o2.length - 1);
+                e4 && 0 === e4.getCode() && 1 === e4.getWidth() && 2 === n2.getCell(0)?.getWidth() && (a = a.slice(0, -1));
+              }
+              if (s2.push(a), !h) break;
+              r2.push(r2[r2.length - 1] + a.length), e3++, o2 = n2;
+            }
+            return [s2.join(""), r2];
+          }
+          _selectResult(e3, t3, i2) {
+            const s2 = this._terminal;
+            if (this._selectedDecoration.clear(), !e3) return s2.clearSelection(), false;
+            if (s2.select(e3.col, e3.row, e3.size), t3) {
+              const i3 = s2.registerMarker(-s2.buffer.active.baseY - s2.buffer.active.cursorY + e3.row);
+              if (i3) {
+                const o2 = s2.registerDecoration({ marker: i3, x: e3.col, width: e3.size, backgroundColor: t3.activeMatchBackground, layer: "top", overviewRulerOptions: { color: t3.activeMatchColorOverviewRuler } });
+                if (o2) {
+                  const s3 = [];
+                  s3.push(i3), s3.push(o2.onRender(((e4) => this._applyStyles(e4, t3.activeMatchBorder, true)))), s3.push(o2.onDispose((() => (0, r.disposeArray)(s3)))), this._selectedDecoration.value = { decoration: o2, match: e3, dispose() {
+                    o2.dispose();
+                  } };
+                }
+              }
+            }
+            if (!i2 && (e3.row >= s2.buffer.active.viewportY + s2.rows || e3.row < s2.buffer.active.viewportY)) {
+              let t4 = e3.row - s2.buffer.active.viewportY;
+              t4 -= Math.floor(s2.rows / 2), s2.scrollLines(t4);
+            }
+            return true;
+          }
+          _applyStyles(e3, t3, i2) {
+            e3.classList.contains("xterm-find-result-decoration") || (e3.classList.add("xterm-find-result-decoration"), t3 && (e3.style.outline = `1px solid ${t3}`)), i2 && e3.classList.add("xterm-find-active-result-decoration");
+          }
+          _createResultDecoration(e3, t3) {
+            const i2 = this._terminal, s2 = i2.registerMarker(-i2.buffer.active.baseY - i2.buffer.active.cursorY + e3.row);
+            if (!s2) return;
+            const o2 = i2.registerDecoration({ marker: s2, x: e3.col, width: e3.size, backgroundColor: t3.matchBackground, overviewRulerOptions: this._highlightedLines.has(s2.line) ? void 0 : { color: t3.matchOverviewRuler, position: "center" } });
+            if (o2) {
+              const e4 = [];
+              e4.push(s2), e4.push(o2.onRender(((e5) => this._applyStyles(e5, t3.matchBorder, false)))), e4.push(o2.onDispose((() => (0, r.disposeArray)(e4))));
+            }
+            return o2;
+          }
+        }
+        e2.SearchAddon = n;
+      })(), s;
+    })()));
+  }
+});
+export default require_addon_search();
+//# sourceMappingURL=@xterm_addon-search.js.map

web/node_modules/.vite/deps/_metadata.json

@@ -0,0 +1,649 @@
+{
+  "hash": "d7f73599",
+  "configHash": "895aa371",
+  "lockfileHash": "a37435b2",
+  "browserHash": "8f9162de",
+  "optimized": {
+    "react": {
+      "src": "../../react/index.js",
+      "file": "react.js",
+      "fileHash": "256bf750",
+      "needsInterop": true
+    },
+    "react-dom": {
+      "src": "../../react-dom/index.js",
+      "file": "react-dom.js",
+      "fileHash": "97939212",
+      "needsInterop": true
+    },
+    "react/jsx-dev-runtime": {
+      "src": "../../react/jsx-dev-runtime.js",
+      "file": "react_jsx-dev-runtime.js",
+      "fileHash": "5979d284",
+      "needsInterop": true
+    },
+    "react/jsx-runtime": {
+      "src": "../../react/jsx-runtime.js",
+      "file": "react_jsx-runtime.js",
+      "fileHash": "fe143021",
+      "needsInterop": true
+    },
+    "@ant-design/colors": {
+      "src": "../../@ant-design/colors/es/index.js",
+      "file": "@ant-design_colors.js",
+      "fileHash": "435a36ea",
+      "needsInterop": false
+    },
+    "@ant-design/cssinjs": {
+      "src": "../../@ant-design/cssinjs/es/index.js",
+      "file": "@ant-design_cssinjs.js",
+      "fileHash": "d790e619",
+      "needsInterop": false
+    },
+    "@ant-design/icons": {
+      "src": "../../@ant-design/icons/es/index.js",
+      "file": "@ant-design_icons.js",
+      "fileHash": "890f79a2",
+      "needsInterop": false
+    },
+    "@ant-design/pro-components": {
+      "src": "../../@ant-design/pro-components/es/index.js",
+      "file": "@ant-design_pro-components.js",
+      "fileHash": "9cd295e4",
+      "needsInterop": false
+    },
+    "@dnd-kit/core": {
+      "src": "../../@dnd-kit/core/dist/core.esm.js",
+      "file": "@dnd-kit_core.js",
+      "fileHash": "e35f1a62",
+      "needsInterop": false
+    },
+    "@dnd-kit/sortable": {
+      "src": "../../@dnd-kit/sortable/dist/sortable.esm.js",
+      "file": "@dnd-kit_sortable.js",
+      "fileHash": "d72aba13",
+      "needsInterop": false
+    },
+    "@dnd-kit/utilities": {
+      "src": "../../@dnd-kit/utilities/dist/utilities.esm.js",
+      "file": "@dnd-kit_utilities.js",
+      "fileHash": "1a9fd92b",
+      "needsInterop": false
+    },
+    "@dushixiang/guacamole-common-js": {
+      "src": "../../@dushixiang/guacamole-common-js/dist/esm/guacamole-common.js",
+      "file": "@dushixiang_guacamole-common-js.js",
+      "fileHash": "06185099",
+      "needsInterop": false
+    },
+    "@monaco-editor/react": {
+      "src": "../../@monaco-editor/react/dist/index.mjs",
+      "file": "@monaco-editor_react.js",
+      "fileHash": "e5938b6c",
+      "needsInterop": false
+    },
+    "@radix-ui/react-scroll-area": {
+      "src": "../../@radix-ui/react-scroll-area/dist/index.mjs",
+      "file": "@radix-ui_react-scroll-area.js",
+      "fileHash": "ef4aca0d",
+      "needsInterop": false
+    },
+    "@simplewebauthn/browser": {
+      "src": "../../@simplewebauthn/browser/esm/index.js",
+      "file": "@simplewebauthn_browser.js",
+      "fileHash": "4875c01a",
+      "needsInterop": false
+    },
+    "@tanstack/react-query": {
+      "src": "../../@tanstack/react-query/build/modern/index.js",
+      "file": "@tanstack_react-query.js",
+      "fileHash": "e6037089",
+      "needsInterop": false
+    },
+    "@xterm/addon-canvas": {
+      "src": "../../@xterm/addon-canvas/lib/addon-canvas.js",
+      "file": "@xterm_addon-canvas.js",
+      "fileHash": "a6a6fe34",
+      "needsInterop": true
+    },
+    "@xterm/addon-fit": {
+      "src": "../../@xterm/addon-fit/lib/addon-fit.js",
+      "file": "@xterm_addon-fit.js",
+      "fileHash": "94eb1703",
+      "needsInterop": true
+    },
+    "@xterm/addon-search": {
+      "src": "../../@xterm/addon-search/lib/addon-search.js",
+      "file": "@xterm_addon-search.js",
+      "fileHash": "5f56ae0a",
+      "needsInterop": true
+    },
+    "@xterm/addon-webgl": {
+      "src": "../../@xterm/addon-webgl/lib/addon-webgl.js",
+      "file": "@xterm_addon-webgl.js",
+      "fileHash": "a0505b9c",
+      "needsInterop": true
+    },
+    "@xterm/xterm": {
+      "src": "../../@xterm/xterm/lib/xterm.js",
+      "file": "@xterm_xterm.js",
+      "fileHash": "b88a4170",
+      "needsInterop": true
+    },
+    "antd": {
+      "src": "../../antd/es/index.js",
+      "file": "antd.js",
+      "fileHash": "ff5a1203",
+      "needsInterop": false
+    },
+    "antd/locale/en_US": {
+      "src": "../../antd/locale/en_US.js",
+      "file": "antd_locale_en_US.js",
+      "fileHash": "1200056b",
+      "needsInterop": true
+    },
+    "antd/locale/ja_JP": {
+      "src": "../../antd/locale/ja_JP.js",
+      "file": "antd_locale_ja_JP.js",
+      "fileHash": "c5104bef",
+      "needsInterop": true
+    },
+    "antd/locale/zh_CN": {
+      "src": "../../antd/locale/zh_CN.js",
+      "file": "antd_locale_zh_CN.js",
+      "fileHash": "91cad63f",
+      "needsInterop": true
+    },
+    "antd/locale/zh_TW": {
+      "src": "../../antd/locale/zh_TW.js",
+      "file": "antd_locale_zh_TW.js",
+      "fileHash": "b00de281",
+      "needsInterop": true
+    },
+    "asciinema-player": {
+      "src": "../../asciinema-player/dist/index.js",
+      "file": "asciinema-player.js",
+      "fileHash": "55c1d4f7",
+      "needsInterop": false
+    },
+    "clsx": {
+      "src": "../../clsx/dist/clsx.mjs",
+      "file": "clsx.js",
+      "fileHash": "9d4925bf",
+      "needsInterop": false
+    },
+    "copy-to-clipboard": {
+      "src": "../../copy-to-clipboard/index.js",
+      "file": "copy-to-clipboard.js",
+      "fileHash": "3cf3f666",
+      "needsInterop": true
+    },
+    "dayjs": {
+      "src": "../../dayjs/dayjs.min.js",
+      "file": "dayjs.js",
+      "fileHash": "567bd51a",
+      "needsInterop": true
+    },
+    "dayjs/plugin/relativeTime": {
+      "src": "../../dayjs/plugin/relativeTime.js",
+      "file": "dayjs_plugin_relativeTime.js",
+      "fileHash": "9394329a",
+      "needsInterop": true
+    },
+    "i18next": {
+      "src": "../../i18next/dist/esm/i18next.js",
+      "file": "i18next.js",
+      "fileHash": "0e972435",
+      "needsInterop": false
+    },
+    "i18next-browser-languagedetector": {
+      "src": "../../i18next-browser-languagedetector/dist/esm/i18nextBrowserLanguageDetector.js",
+      "file": "i18next-browser-languagedetector.js",
+      "fileHash": "5c2cd4f3",
+      "needsInterop": false
+    },
+    "jotai": {
+      "src": "../../jotai/esm/index.mjs",
+      "file": "jotai.js",
+      "fileHash": "4f005c1f",
+      "needsInterop": false
+    },
+    "jotai/index": {
+      "src": "../../jotai/esm/index.mjs",
+      "file": "jotai_index.js",
+      "fileHash": "704b5e49",
+      "needsInterop": false
+    },
+    "js-base64": {
+      "src": "../../js-base64/base64.mjs",
+      "file": "js-base64.js",
+      "fileHash": "3183a045",
+      "needsInterop": false
+    },
+    "lucide-react": {
+      "src": "../../lucide-react/dist/esm/lucide-react.js",
+      "file": "lucide-react.js",
+      "fileHash": "767ad8b9",
+      "needsInterop": false
+    },
+    "monaco-editor": {
+      "src": "../../monaco-editor/esm/vs/editor/editor.main.js",
+      "file": "monaco-editor.js",
+      "fileHash": "6bf49474",
+      "needsInterop": false
+    },
+    "qs": {
+      "src": "../../qs/lib/index.js",
+      "file": "qs.js",
+      "fileHash": "af6a0bea",
+      "needsInterop": true
+    },
+    "react-countup": {
+      "src": "../../react-countup/build/index.js",
+      "file": "react-countup.js",
+      "fileHash": "1bb9c7b2",
+      "needsInterop": true
+    },
+    "react-dom/client": {
+      "src": "../../react-dom/client.js",
+      "file": "react-dom_client.js",
+      "fileHash": "2a12b033",
+      "needsInterop": true
+    },
+    "react-i18next": {
+      "src": "../../react-i18next/dist/es/index.js",
+      "file": "react-i18next.js",
+      "fileHash": "a8ce8954",
+      "needsInterop": false
+    },
+    "react-resizable-panels": {
+      "src": "../../react-resizable-panels/dist/react-resizable-panels.browser.development.js",
+      "file": "react-resizable-panels.js",
+      "fileHash": "1126271a",
+      "needsInterop": false
+    },
+    "react-router-dom": {
+      "src": "../../react-router-dom/dist/index.mjs",
+      "file": "react-router-dom.js",
+      "fileHash": "f4021ef3",
+      "needsInterop": false
+    },
+    "react-spinners": {
+      "src": "../../react-spinners/esm/index.js",
+      "file": "react-spinners.js",
+      "fileHash": "efdf8194",
+      "needsInterop": false
+    },
+    "react-use": {
+      "src": "../../react-use/esm/index.js",
+      "file": "react-use.js",
+      "fileHash": "0125b326",
+      "needsInterop": false
+    },
+    "recharts": {
+      "src": "../../recharts/es6/index.js",
+      "file": "recharts.js",
+      "fileHash": "5ed02992",
+      "needsInterop": false
+    },
+    "tailwind-merge": {
+      "src": "../../tailwind-merge/dist/bundle-mjs.mjs",
+      "file": "tailwind-merge.js",
+      "fileHash": "70e3d974",
+      "needsInterop": false
+    }
+  },
+  "chunks": {
+    "typespec-O24IKWL7": {
+      "file": "typespec-O24IKWL7.js"
+    },
+    "vb-UXTYN4CT": {
+      "file": "vb-UXTYN4CT.js"
+    },
+    "wgsl-EASP57TO": {
+      "file": "wgsl-EASP57TO.js"
+    },
+    "xml-ZCD7ASJQ": {
+      "file": "xml-ZCD7ASJQ.js"
+    },
+    "yaml-F6BXZQRL": {
+      "file": "yaml-F6BXZQRL.js"
+    },
+    "sophia-5WBZN4VG": {
+      "file": "sophia-5WBZN4VG.js"
+    },
+    "sparql-FDJSTRYM": {
+      "file": "sparql-FDJSTRYM.js"
+    },
+    "sql-FQDHVNM5": {
+      "file": "sql-FQDHVNM5.js"
+    },
+    "st-NSNOUKQ5": {
+      "file": "st-NSNOUKQ5.js"
+    },
+    "swift-IS2NNQEK": {
+      "file": "swift-IS2NNQEK.js"
+    },
+    "systemverilog-OXVRFGRV": {
+      "file": "systemverilog-OXVRFGRV.js"
+    },
+    "tcl-MRYTMHE3": {
+      "file": "tcl-MRYTMHE3.js"
+    },
+    "twig-LVCXZP5C": {
+      "file": "twig-LVCXZP5C.js"
+    },
+    "ruby-YY5SJLZU": {
+      "file": "ruby-YY5SJLZU.js"
+    },
+    "rust-GABLANL4": {
+      "file": "rust-GABLANL4.js"
+    },
+    "sb-ZYOOUK6N": {
+      "file": "sb-ZYOOUK6N.js"
+    },
+    "scala-EH4IIU62": {
+      "file": "scala-EH4IIU62.js"
+    },
+    "scheme-CR6XJS5T": {
+      "file": "scheme-CR6XJS5T.js"
+    },
+    "scss-AEB5QUZ6": {
+      "file": "scss-AEB5QUZ6.js"
+    },
+    "shell-IPAEB5WR": {
+      "file": "shell-IPAEB5WR.js"
+    },
+    "solidity-3MWH22VK": {
+      "file": "solidity-3MWH22VK.js"
+    },
+    "pug-NXACL23N": {
+      "file": "pug-NXACL23N.js"
+    },
+    "python-YG7OV4D2": {
+      "file": "python-YG7OV4D2.js"
+    },
+    "qsharp-RYWZUKXK": {
+      "file": "qsharp-RYWZUKXK.js"
+    },
+    "r-P5JJCAYD": {
+      "file": "r-P5JJCAYD.js"
+    },
+    "razor-QISZWQRO": {
+      "file": "razor-QISZWQRO.js"
+    },
+    "redis-MUBO6WP4": {
+      "file": "redis-MUBO6WP4.js"
+    },
+    "redshift-E35JZSNZ": {
+      "file": "redshift-E35JZSNZ.js"
+    },
+    "restructuredtext-D7DYILMY": {
+      "file": "restructuredtext-D7DYILMY.js"
+    },
+    "perl-HMQVFLRX": {
+      "file": "perl-HMQVFLRX.js"
+    },
+    "pgsql-NUFSNP7Y": {
+      "file": "pgsql-NUFSNP7Y.js"
+    },
+    "php-7OYMCS7F": {
+      "file": "php-7OYMCS7F.js"
+    },
+    "pla-UJG7OQZP": {
+      "file": "pla-UJG7OQZP.js"
+    },
+    "postiats-DFAYHZKA": {
+      "file": "postiats-DFAYHZKA.js"
+    },
+    "powerquery-P6DE4P7D": {
+      "file": "powerquery-P6DE4P7D.js"
+    },
+    "powershell-EHMMC5JA": {
+      "file": "powershell-EHMMC5JA.js"
+    },
+    "protobuf-C4B34BWX": {
+      "file": "protobuf-C4B34BWX.js"
+    },
+    "markdown-S72TDLUP": {
+      "file": "markdown-S72TDLUP.js"
+    },
+    "mdx-GGZOAKTK": {
+      "file": "mdx-GGZOAKTK.js"
+    },
+    "mips-5KX5OKVV": {
+      "file": "mips-5KX5OKVV.js"
+    },
+    "msdax-OWI5O5VP": {
+      "file": "msdax-OWI5O5VP.js"
+    },
+    "mysql-TAI77EDJ": {
+      "file": "mysql-TAI77EDJ.js"
+    },
+    "objective-c-4XTEMLW3": {
+      "file": "objective-c-4XTEMLW3.js"
+    },
+    "pascal-SCPEQJFR": {
+      "file": "pascal-SCPEQJFR.js"
+    },
+    "pascaligo-2MUSJBDC": {
+      "file": "pascaligo-2MUSJBDC.js"
+    },
+    "javascript-YS5ITTDE": {
+      "file": "javascript-YS5ITTDE.js"
+    },
+    "julia-PLPORNPV": {
+      "file": "julia-PLPORNPV.js"
+    },
+    "kotlin-RX4TMYFY": {
+      "file": "kotlin-RX4TMYFY.js"
+    },
+    "less-RTHD2YES": {
+      "file": "less-RTHD2YES.js"
+    },
+    "lexon-ZI3D4SST": {
+      "file": "lexon-ZI3D4SST.js"
+    },
+    "lua-YEHU2J2S": {
+      "file": "lua-YEHU2J2S.js"
+    },
+    "liquid-WEWTCAQE": {
+      "file": "liquid-WEWTCAQE.js"
+    },
+    "m3-NOXPZE3D": {
+      "file": "m3-NOXPZE3D.js"
+    },
+    "go-P2YFQ7FL": {
+      "file": "go-P2YFQ7FL.js"
+    },
+    "graphql-3DE36JVJ": {
+      "file": "graphql-3DE36JVJ.js"
+    },
+    "handlebars-HPDX43KC": {
+      "file": "handlebars-HPDX43KC.js"
+    },
+    "hcl-XOV326Z5": {
+      "file": "hcl-XOV326Z5.js"
+    },
+    "html-RXW7N2NE": {
+      "file": "html-RXW7N2NE.js"
+    },
+    "ini-7B724RC3": {
+      "file": "ini-7B724RC3.js"
+    },
+    "java-M5CQLM7Y": {
+      "file": "java-M5CQLM7Y.js"
+    },
+    "typescript-SFNJ7QI4": {
+      "file": "typescript-SFNJ7QI4.js"
+    },
+    "chunk-5SEBTWNG": {
+      "file": "chunk-5SEBTWNG.js"
+    },
+    "cypher-5ICXKU2P": {
+      "file": "cypher-5ICXKU2P.js"
+    },
+    "dart-3UCVCDXP": {
+      "file": "dart-3UCVCDXP.js"
+    },
+    "dockerfile-IYOP4NQV": {
+      "file": "dockerfile-IYOP4NQV.js"
+    },
+    "ecl-VKO4CPXX": {
+      "file": "ecl-VKO4CPXX.js"
+    },
+    "elixir-54RYSFBL": {
+      "file": "elixir-54RYSFBL.js"
+    },
+    "flow9-RM3Z24X4": {
+      "file": "flow9-RM3Z24X4.js"
+    },
+    "fsharp-K4NXQBMT": {
+      "file": "fsharp-K4NXQBMT.js"
+    },
+    "freemarker2-426F2L6N": {
+      "file": "freemarker2-426F2L6N.js"
+    },
+    "bicep-KHSV6VEI": {
+      "file": "bicep-KHSV6VEI.js"
+    },
+    "cameligo-NOFINCMB": {
+      "file": "cameligo-NOFINCMB.js"
+    },
+    "clojure-UQ4YAO3T": {
+      "file": "clojure-UQ4YAO3T.js"
+    },
+    "coffee-MMW3VBQ7": {
+      "file": "coffee-MMW3VBQ7.js"
+    },
+    "cpp-7BUZANNW": {
+      "file": "cpp-7BUZANNW.js"
+    },
+    "csharp-PP7HMUYL": {
+      "file": "csharp-PP7HMUYL.js"
+    },
+    "csp-OXUZ7OXN": {
+      "file": "csp-OXUZ7OXN.js"
+    },
+    "css-JOJ6PHWV": {
+      "file": "css-JOJ6PHWV.js"
+    },
+    "cssMode-SJOHF67N": {
+      "file": "cssMode-SJOHF67N.js"
+    },
+    "htmlMode-B3GAEBRP": {
+      "file": "htmlMode-B3GAEBRP.js"
+    },
+    "jsonMode-LIQIEDCD": {
+      "file": "jsonMode-LIQIEDCD.js"
+    },
+    "chunk-EKUYBXO2": {
+      "file": "chunk-EKUYBXO2.js"
+    },
+    "tsMode-2UWV2PW7": {
+      "file": "tsMode-2UWV2PW7.js"
+    },
+    "abap-RTQWGW2D": {
+      "file": "abap-RTQWGW2D.js"
+    },
+    "apex-XVBKQMXD": {
+      "file": "apex-XVBKQMXD.js"
+    },
+    "azcli-GM3WENR2": {
+      "file": "azcli-GM3WENR2.js"
+    },
+    "bat-F5HQNANB": {
+      "file": "bat-F5HQNANB.js"
+    },
+    "chunk-O3FGDFJ7": {
+      "file": "chunk-O3FGDFJ7.js"
+    },
+    "chunk-EAZ3M6A4": {
+      "file": "chunk-EAZ3M6A4.js"
+    },
+    "chunk-GUNMJBQ5": {
+      "file": "chunk-GUNMJBQ5.js"
+    },
+    "chunk-U7P2NEEE": {
+      "file": "chunk-U7P2NEEE.js"
+    },
+    "chunk-DOMCSPSI": {
+      "file": "chunk-DOMCSPSI.js"
+    },
+    "chunk-I6HM5P5L": {
+      "file": "chunk-I6HM5P5L.js"
+    },
+    "chunk-Y4UKYHFZ": {
+      "file": "chunk-Y4UKYHFZ.js"
+    },
+    "chunk-SYSZVICC": {
+      "file": "chunk-SYSZVICC.js"
+    },
+    "chunk-KNOBAKGH": {
+      "file": "chunk-KNOBAKGH.js"
+    },
+    "chunk-7KEXXFT5": {
+      "file": "chunk-7KEXXFT5.js"
+    },
+    "chunk-V6KE24I5": {
+      "file": "chunk-V6KE24I5.js"
+    },
+    "chunk-KSAUAMBE": {
+      "file": "chunk-KSAUAMBE.js"
+    },
+    "chunk-ARCWD47H": {
+      "file": "chunk-ARCWD47H.js"
+    },
+    "chunk-O3TGDUAO": {
+      "file": "chunk-O3TGDUAO.js"
+    },
+    "chunk-LSZRMDFG": {
+      "file": "chunk-LSZRMDFG.js"
+    },
+    "chunk-6VAXZ5AU": {
+      "file": "chunk-6VAXZ5AU.js"
+    },
+    "chunk-3DUEC4BE": {
+      "file": "chunk-3DUEC4BE.js"
+    },
+    "chunk-MNF4PNE3": {
+      "file": "chunk-MNF4PNE3.js"
+    },
+    "chunk-PLXMHLGL": {
+      "file": "chunk-PLXMHLGL.js"
+    },
+    "chunk-BRVJJCPY": {
+      "file": "chunk-BRVJJCPY.js"
+    },
+    "chunk-ZOTMVMBQ": {
+      "file": "chunk-ZOTMVMBQ.js"
+    },
+    "chunk-2UYAFQ3I": {
+      "file": "chunk-2UYAFQ3I.js"
+    },
+    "chunk-5T3YOWZX": {
+      "file": "chunk-5T3YOWZX.js"
+    },
+    "chunk-DINYHDVU": {
+      "file": "chunk-DINYHDVU.js"
+    },
+    "chunk-FSGBSGQ2": {
+      "file": "chunk-FSGBSGQ2.js"
+    },
+    "chunk-KBMHTFOP": {
+      "file": "chunk-KBMHTFOP.js"
+    },
+    "chunk-4NTHFIFD": {
+      "file": "chunk-4NTHFIFD.js"
+    },
+    "chunk-7ZNOTH45": {
+      "file": "chunk-7ZNOTH45.js"
+    },
+    "chunk-R546NDVX": {
+      "file": "chunk-R546NDVX.js"
+    },
+    "chunk-V4OQ3NZ2": {
+      "file": "chunk-V4OQ3NZ2.js"
+    }
+  }
+}

web/node_modules/.vite/deps/antd.js

@@ -0,0 +1,166 @@
+"use client";
+import {
+  affix_default,
+  alert_default,
+  anchor_default,
+  app_default,
+  auto_complete_default,
+  avatar_default,
+  back_top_default,
+  badge_default,
+  breadcrumb_default,
+  button_default,
+  calendar_default,
+  card_default,
+  carousel_default,
+  cascader_default,
+  checkbox_default,
+  col_default,
+  collapse_default,
+  color_picker_default,
+  config_provider_default,
+  date_picker_default,
+  descriptions_default,
+  divider_default,
+  drawer_default,
+  dropdown_default,
+  empty_default,
+  flex_default,
+  float_button_default,
+  form_default,
+  grid_default,
+  image_default,
+  input_default,
+  input_number_default,
+  layout_default,
+  list_default,
+  mentions_default,
+  menu_default,
+  message_default,
+  modal_default,
+  notification_default,
+  pagination_default,
+  popconfirm_default,
+  popover_default,
+  progress_default,
+  qr_code_default,
+  radio_default,
+  rate_default,
+  result_default,
+  row_default,
+  segmented_default,
+  select_default,
+  skeleton_default,
+  slider_default,
+  space_default,
+  spin_default,
+  splitter_default,
+  statistic_default,
+  steps_default,
+  switch_default,
+  table_default,
+  tabs_default,
+  tag_default,
+  theme_default,
+  time_picker_default,
+  timeline_default,
+  tooltip_default,
+  tour_default,
+  transfer_default,
+  tree_default,
+  tree_select_default,
+  typography_default,
+  unstableSetRender,
+  upload_default,
+  version_default,
+  watermark_default
+} from "./chunk-V6KE24I5.js";
+import "./chunk-KSAUAMBE.js";
+import "./chunk-ARCWD47H.js";
+import "./chunk-MNF4PNE3.js";
+import "./chunk-ZOTMVMBQ.js";
+import "./chunk-2UYAFQ3I.js";
+import "./chunk-5T3YOWZX.js";
+import "./chunk-DINYHDVU.js";
+import "./chunk-FSGBSGQ2.js";
+import "./chunk-KBMHTFOP.js";
+import "./chunk-4NTHFIFD.js";
+import "./chunk-7ZNOTH45.js";
+import "./chunk-R546NDVX.js";
+import "./chunk-V4OQ3NZ2.js";
+export {
+  affix_default as Affix,
+  alert_default as Alert,
+  anchor_default as Anchor,
+  app_default as App,
+  auto_complete_default as AutoComplete,
+  avatar_default as Avatar,
+  back_top_default as BackTop,
+  badge_default as Badge,
+  breadcrumb_default as Breadcrumb,
+  button_default as Button,
+  calendar_default as Calendar,
+  card_default as Card,
+  carousel_default as Carousel,
+  cascader_default as Cascader,
+  checkbox_default as Checkbox,
+  col_default as Col,
+  collapse_default as Collapse,
+  color_picker_default as ColorPicker,
+  config_provider_default as ConfigProvider,
+  date_picker_default as DatePicker,
+  descriptions_default as Descriptions,
+  divider_default as Divider,
+  drawer_default as Drawer,
+  dropdown_default as Dropdown,
+  empty_default as Empty,
+  flex_default as Flex,
+  float_button_default as FloatButton,
+  form_default as Form,
+  grid_default as Grid,
+  image_default as Image,
+  input_default as Input,
+  input_number_default as InputNumber,
+  layout_default as Layout,
+  list_default as List,
+  mentions_default as Mentions,
+  menu_default as Menu,
+  modal_default as Modal,
+  pagination_default as Pagination,
+  popconfirm_default as Popconfirm,
+  popover_default as Popover,
+  progress_default as Progress,
+  qr_code_default as QRCode,
+  radio_default as Radio,
+  rate_default as Rate,
+  result_default as Result,
+  row_default as Row,
+  segmented_default as Segmented,
+  select_default as Select,
+  skeleton_default as Skeleton,
+  slider_default as Slider,
+  space_default as Space,
+  spin_default as Spin,
+  splitter_default as Splitter,
+  statistic_default as Statistic,
+  steps_default as Steps,
+  switch_default as Switch,
+  table_default as Table,
+  tabs_default as Tabs,
+  tag_default as Tag,
+  time_picker_default as TimePicker,
+  timeline_default as Timeline,
+  tooltip_default as Tooltip,
+  tour_default as Tour,
+  transfer_default as Transfer,
+  tree_default as Tree,
+  tree_select_default as TreeSelect,
+  typography_default as Typography,
+  upload_default as Upload,
+  watermark_default as Watermark,
+  message_default as message,
+  notification_default as notification,
+  theme_default as theme,
+  unstableSetRender,
+  version_default as version
+};

web/node_modules/.vite/deps/antd.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [],
+  "mappings": "",
+  "names": []
+}

web/node_modules/.vite/deps/antd_locale_en_US.js

@@ -0,0 +1,307 @@
+import {
+  require_common
+} from "./chunk-Y4UKYHFZ.js";
+import {
+  require_interopRequireDefault,
+  require_objectSpread2
+} from "./chunk-O3TGDUAO.js";
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/rc-pagination/lib/locale/en_US.js
+var require_en_US = __commonJS({
+  "node_modules/rc-pagination/lib/locale/en_US.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      // Options
+      items_per_page: "/ page",
+      jump_to: "Go to",
+      jump_to_confirm: "confirm",
+      page: "Page",
+      // Pagination
+      prev_page: "Previous Page",
+      next_page: "Next Page",
+      prev_5: "Previous 5 Pages",
+      next_5: "Next 5 Pages",
+      prev_3: "Previous 3 Pages",
+      next_3: "Next 3 Pages",
+      page_size: "Page Size"
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/rc-picker/lib/locale/en_US.js
+var require_en_US2 = __commonJS({
+  "node_modules/rc-picker/lib/locale/en_US.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _objectSpread2 = _interopRequireDefault(require_objectSpread2());
+    var _common = require_common();
+    var locale = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _common.commonLocale), {}, {
+      locale: "en_US",
+      today: "Today",
+      now: "Now",
+      backToToday: "Back to today",
+      ok: "OK",
+      clear: "Clear",
+      week: "Week",
+      month: "Month",
+      year: "Year",
+      timeSelect: "select time",
+      dateSelect: "select date",
+      weekSelect: "Choose a week",
+      monthSelect: "Choose a month",
+      yearSelect: "Choose a year",
+      decadeSelect: "Choose a decade",
+      dateFormat: "M/D/YYYY",
+      dateTimeFormat: "M/D/YYYY HH:mm:ss",
+      previousMonth: "Previous month (PageUp)",
+      nextMonth: "Next month (PageDown)",
+      previousYear: "Last year (Control + left)",
+      nextYear: "Next year (Control + right)",
+      previousDecade: "Last decade",
+      nextDecade: "Next decade",
+      previousCentury: "Last century",
+      nextCentury: "Next century"
+    });
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/time-picker/locale/en_US.js
+var require_en_US3 = __commonJS({
+  "node_modules/antd/lib/time-picker/locale/en_US.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      placeholder: "Select time",
+      rangePlaceholder: ["Start time", "End time"]
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/date-picker/locale/en_US.js
+var require_en_US4 = __commonJS({
+  "node_modules/antd/lib/date-picker/locale/en_US.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _en_US = _interopRequireDefault(require_en_US2());
+    var _en_US2 = _interopRequireDefault(require_en_US3());
+    var locale = {
+      lang: Object.assign({
+        placeholder: "Select date",
+        yearPlaceholder: "Select year",
+        quarterPlaceholder: "Select quarter",
+        monthPlaceholder: "Select month",
+        weekPlaceholder: "Select week",
+        rangePlaceholder: ["Start date", "End date"],
+        rangeYearPlaceholder: ["Start year", "End year"],
+        rangeQuarterPlaceholder: ["Start quarter", "End quarter"],
+        rangeMonthPlaceholder: ["Start month", "End month"],
+        rangeWeekPlaceholder: ["Start week", "End week"]
+      }, _en_US.default),
+      timePickerLocale: Object.assign({}, _en_US2.default)
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/calendar/locale/en_US.js
+var require_en_US5 = __commonJS({
+  "node_modules/antd/lib/calendar/locale/en_US.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _en_US = _interopRequireDefault(require_en_US4());
+    var _default = exports.default = _en_US.default;
+  }
+});
+
+// node_modules/antd/lib/locale/en_US.js
+var require_en_US6 = __commonJS({
+  "node_modules/antd/lib/locale/en_US.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _en_US = _interopRequireDefault(require_en_US());
+    var _en_US2 = _interopRequireDefault(require_en_US5());
+    var _en_US3 = _interopRequireDefault(require_en_US4());
+    var _en_US4 = _interopRequireDefault(require_en_US3());
+    var typeTemplate = "${label} is not a valid ${type}";
+    var localeValues = {
+      locale: "en",
+      Pagination: _en_US.default,
+      DatePicker: _en_US3.default,
+      TimePicker: _en_US4.default,
+      Calendar: _en_US2.default,
+      global: {
+        placeholder: "Please select",
+        close: "Close"
+      },
+      Table: {
+        filterTitle: "Filter menu",
+        filterConfirm: "OK",
+        filterReset: "Reset",
+        filterEmptyText: "No filters",
+        filterCheckAll: "Select all items",
+        filterSearchPlaceholder: "Search in filters",
+        emptyText: "No data",
+        selectAll: "Select current page",
+        selectInvert: "Invert current page",
+        selectNone: "Clear all data",
+        selectionAll: "Select all data",
+        sortTitle: "Sort",
+        expand: "Expand row",
+        collapse: "Collapse row",
+        triggerDesc: "Click to sort descending",
+        triggerAsc: "Click to sort ascending",
+        cancelSort: "Click to cancel sorting"
+      },
+      Tour: {
+        Next: "Next",
+        Previous: "Previous",
+        Finish: "Finish"
+      },
+      Modal: {
+        okText: "OK",
+        cancelText: "Cancel",
+        justOkText: "OK"
+      },
+      Popconfirm: {
+        okText: "OK",
+        cancelText: "Cancel"
+      },
+      Transfer: {
+        titles: ["", ""],
+        searchPlaceholder: "Search here",
+        itemUnit: "item",
+        itemsUnit: "items",
+        remove: "Remove",
+        selectCurrent: "Select current page",
+        removeCurrent: "Remove current page",
+        selectAll: "Select all data",
+        deselectAll: "Deselect all data",
+        removeAll: "Remove all data",
+        selectInvert: "Invert current page"
+      },
+      Upload: {
+        uploading: "Uploading...",
+        removeFile: "Remove file",
+        uploadError: "Upload error",
+        previewFile: "Preview file",
+        downloadFile: "Download file"
+      },
+      Empty: {
+        description: "No data"
+      },
+      Icon: {
+        icon: "icon"
+      },
+      Text: {
+        edit: "Edit",
+        copy: "Copy",
+        copied: "Copied",
+        expand: "Expand",
+        collapse: "Collapse"
+      },
+      Form: {
+        optional: "(optional)",
+        defaultValidateMessages: {
+          default: "Field validation error for ${label}",
+          required: "Please enter ${label}",
+          enum: "${label} must be one of [${enum}]",
+          whitespace: "${label} cannot be a blank character",
+          date: {
+            format: "${label} date format is invalid",
+            parse: "${label} cannot be converted to a date",
+            invalid: "${label} is an invalid date"
+          },
+          types: {
+            string: typeTemplate,
+            method: typeTemplate,
+            array: typeTemplate,
+            object: typeTemplate,
+            number: typeTemplate,
+            date: typeTemplate,
+            boolean: typeTemplate,
+            integer: typeTemplate,
+            float: typeTemplate,
+            regexp: typeTemplate,
+            email: typeTemplate,
+            url: typeTemplate,
+            hex: typeTemplate
+          },
+          string: {
+            len: "${label} must be ${len} characters",
+            min: "${label} must be at least ${min} characters",
+            max: "${label} must be up to ${max} characters",
+            range: "${label} must be between ${min}-${max} characters"
+          },
+          number: {
+            len: "${label} must be equal to ${len}",
+            min: "${label} must be minimum ${min}",
+            max: "${label} must be maximum ${max}",
+            range: "${label} must be between ${min}-${max}"
+          },
+          array: {
+            len: "Must be ${len} ${label}",
+            min: "At least ${min} ${label}",
+            max: "At most ${max} ${label}",
+            range: "The amount of ${label} must be between ${min}-${max}"
+          },
+          pattern: {
+            mismatch: "${label} does not match the pattern ${pattern}"
+          }
+        }
+      },
+      Image: {
+        preview: "Preview"
+      },
+      QRCode: {
+        expired: "QR code expired",
+        refresh: "Refresh",
+        scanned: "Scanned"
+      },
+      ColorPicker: {
+        presetEmpty: "Empty",
+        transparent: "Transparent",
+        singleColor: "Single",
+        gradientColor: "Gradient"
+      }
+    };
+    var _default = exports.default = localeValues;
+  }
+});
+
+// node_modules/antd/locale/en_US.js
+var require_en_US7 = __commonJS({
+  "node_modules/antd/locale/en_US.js"(exports, module) {
+    module.exports = require_en_US6();
+  }
+});
+export default require_en_US7();
+//# sourceMappingURL=antd_locale_en_US.js.map

web/node_modules/.vite/deps/antd_locale_ja_JP.js

@@ -0,0 +1,311 @@
+import {
+  require_common
+} from "./chunk-Y4UKYHFZ.js";
+import {
+  require_interopRequireDefault,
+  require_objectSpread2
+} from "./chunk-O3TGDUAO.js";
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/rc-pagination/lib/locale/ja_JP.js
+var require_ja_JP = __commonJS({
+  "node_modules/rc-pagination/lib/locale/ja_JP.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      // Options
+      items_per_page: "件 / ページ",
+      jump_to: "移動",
+      jump_to_confirm: "確認する",
+      page: "ページ",
+      // Pagination
+      prev_page: "前のページ",
+      next_page: "次のページ",
+      prev_5: "前 5ページ",
+      next_5: "次 5ページ",
+      prev_3: "前 3ページ",
+      next_3: "次 3ページ",
+      page_size: "ページサイズ"
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/rc-picker/lib/locale/ja_JP.js
+var require_ja_JP2 = __commonJS({
+  "node_modules/rc-picker/lib/locale/ja_JP.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _objectSpread2 = _interopRequireDefault(require_objectSpread2());
+    var _common = require_common();
+    var locale = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _common.commonLocale), {}, {
+      locale: "ja_JP",
+      today: "今日",
+      now: "現在時刻",
+      backToToday: "今日に戻る",
+      ok: "確定",
+      timeSelect: "時間を選択",
+      dateSelect: "日時を選択",
+      weekSelect: "週を選択",
+      clear: "クリア",
+      week: "週",
+      month: "月",
+      year: "年",
+      previousMonth: "前月 (ページアップキー)",
+      nextMonth: "翌月 (ページダウンキー)",
+      monthSelect: "月を選択",
+      yearSelect: "年を選択",
+      decadeSelect: "年代を選択",
+      yearFormat: "YYYY年",
+      dateFormat: "YYYY年M月D日",
+      dateTimeFormat: "YYYY年M月D日 HH時mm分ss秒",
+      previousYear: "前年 (Controlを押しながら左キー)",
+      nextYear: "翌年 (Controlを押しながら右キー)",
+      previousDecade: "前の年代",
+      nextDecade: "次の年代",
+      previousCentury: "前の世紀",
+      nextCentury: "次の世紀",
+      monthBeforeYear: false
+    });
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/time-picker/locale/ja_JP.js
+var require_ja_JP3 = __commonJS({
+  "node_modules/antd/lib/time-picker/locale/ja_JP.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      placeholder: "時間を選択",
+      rangePlaceholder: ["開始時間", "終了時間"]
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/date-picker/locale/ja_JP.js
+var require_ja_JP4 = __commonJS({
+  "node_modules/antd/lib/date-picker/locale/ja_JP.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _ja_JP = _interopRequireDefault(require_ja_JP2());
+    var _ja_JP2 = _interopRequireDefault(require_ja_JP3());
+    var locale = {
+      lang: Object.assign({
+        placeholder: "日付を選択",
+        yearPlaceholder: "年を選択",
+        quarterPlaceholder: "四半期を選択",
+        monthPlaceholder: "月を選択",
+        weekPlaceholder: "週を選択",
+        rangePlaceholder: ["開始日付", "終了日付"],
+        rangeYearPlaceholder: ["開始年", "終了年"],
+        rangeMonthPlaceholder: ["開始月", "終了月"],
+        rangeQuarterPlaceholder: ["開始四半期", "終了四半期"],
+        rangeWeekPlaceholder: ["開始週", "終了週"],
+        shortWeekDays: ["日", "月", "火", "水", "木", "金", "土"],
+        shortMonths: ["1月", "2月", "3月", "4月", "5月", "6月", "7月", "8月", "9月", "10月", "11月", "12月"]
+      }, _ja_JP.default),
+      timePickerLocale: Object.assign({}, _ja_JP2.default)
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/calendar/locale/ja_JP.js
+var require_ja_JP5 = __commonJS({
+  "node_modules/antd/lib/calendar/locale/ja_JP.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _ja_JP = _interopRequireDefault(require_ja_JP4());
+    var _default = exports.default = _ja_JP.default;
+  }
+});
+
+// node_modules/antd/lib/locale/ja_JP.js
+var require_ja_JP6 = __commonJS({
+  "node_modules/antd/lib/locale/ja_JP.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _ja_JP = _interopRequireDefault(require_ja_JP());
+    var _ja_JP2 = _interopRequireDefault(require_ja_JP5());
+    var _ja_JP3 = _interopRequireDefault(require_ja_JP4());
+    var _ja_JP4 = _interopRequireDefault(require_ja_JP3());
+    var typeTemplate = "${label}は有効な${type}ではありません";
+    var localeValues = {
+      locale: "ja",
+      Pagination: _ja_JP.default,
+      DatePicker: _ja_JP3.default,
+      TimePicker: _ja_JP4.default,
+      Calendar: _ja_JP2.default,
+      global: {
+        placeholder: "選んでください",
+        close: "閉じる"
+      },
+      Table: {
+        filterTitle: "フィルター",
+        filterConfirm: "OK",
+        filterReset: "リセット",
+        filterEmptyText: "フィルターなし",
+        filterCheckAll: "すべてを選択",
+        filterSearchPlaceholder: "フィルターで検索",
+        emptyText: "データなし",
+        selectAll: "ページ単位で選択",
+        selectInvert: "ページ単位で反転",
+        selectNone: "クリア",
+        selectionAll: "すべてを選択",
+        sortTitle: "ソート",
+        expand: "展開する",
+        collapse: "折り畳む",
+        triggerDesc: "クリックで降順にソート",
+        triggerAsc: "クリックで昇順にソート",
+        cancelSort: "ソートをキャンセル"
+      },
+      Tour: {
+        Next: "次",
+        Previous: "前の",
+        Finish: "仕上げる"
+      },
+      Modal: {
+        okText: "OK",
+        cancelText: "キャンセル",
+        justOkText: "OK"
+      },
+      Popconfirm: {
+        okText: "OK",
+        cancelText: "キャンセル"
+      },
+      Transfer: {
+        titles: ["", ""],
+        searchPlaceholder: "ここを検索",
+        itemUnit: "アイテム",
+        itemsUnit: "アイテム",
+        remove: "削除",
+        selectCurrent: "現在のページを選択",
+        removeCurrent: "現在のページを削除",
+        selectAll: "ページ単位で選択",
+        deselectAll: "すべてのデータの選択を解除する",
+        removeAll: "ページ単位で削除",
+        selectInvert: "ページ単位で反転"
+      },
+      Upload: {
+        uploading: "アップロード中...",
+        removeFile: "ファイルを削除",
+        uploadError: "アップロードエラー",
+        previewFile: "ファイルをプレビュー",
+        downloadFile: "ダウンロードファイル"
+      },
+      Empty: {
+        description: "データがありません"
+      },
+      Icon: {
+        icon: "アイコン"
+      },
+      Text: {
+        edit: "編集",
+        copy: "コピー",
+        copied: "コピーされました",
+        expand: "拡大する",
+        collapse: "崩壊"
+      },
+      Form: {
+        optional: "(オプション)",
+        defaultValidateMessages: {
+          default: "${label}のフィールド検証エラー",
+          required: "${label}を入力してください",
+          enum: "${label}は[${enum}]のいずれかである必要があります",
+          whitespace: "${label}は空白文字にすることはできません",
+          date: {
+            format: "${label}の日付形式は不正です",
+            parse: "${label}は日付に変換できません",
+            invalid: "${label}は不正な日付です"
+          },
+          types: {
+            string: typeTemplate,
+            method: typeTemplate,
+            array: typeTemplate,
+            object: typeTemplate,
+            number: typeTemplate,
+            date: typeTemplate,
+            boolean: typeTemplate,
+            integer: typeTemplate,
+            float: typeTemplate,
+            regexp: typeTemplate,
+            email: typeTemplate,
+            url: typeTemplate,
+            hex: typeTemplate
+          },
+          string: {
+            len: "${label}は${len}文字である必要があります",
+            min: "${label}は${min}文字以上である必要があります",
+            max: "${label}は${max}文字以下である必要があります",
+            range: "${label}は${min}-${max}文字の範囲である必要があります"
+          },
+          number: {
+            len: "${label}は${len}と等しい必要があります",
+            min: "${label}の最小値は${min}です",
+            max: "${label}の最大値は${max}です",
+            range: "${label}は${min}-${max}の範囲である必要があります"
+          },
+          array: {
+            len: "${label}は${len}である必要があります",
+            min: "${label}の最小は${min}です",
+            max: "${label}の最大は${max}です",
+            range: "${label}の合計は${min}-${max}の範囲である必要があります"
+          },
+          pattern: {
+            mismatch: "${label}はパターン${pattern}と一致しません"
+          }
+        }
+      },
+      Image: {
+        preview: "プレビュー"
+      },
+      QRCode: {
+        expired: "QRコードの有効期限が切れました",
+        refresh: "リフレッシュ",
+        scanned: "スキャン済み"
+      },
+      ColorPicker: {
+        presetEmpty: "空の",
+        transparent: "透明",
+        singleColor: "単色",
+        gradientColor: "グラデーション"
+      }
+    };
+    var _default = exports.default = localeValues;
+  }
+});
+
+// node_modules/antd/locale/ja_JP.js
+var require_ja_JP7 = __commonJS({
+  "node_modules/antd/locale/ja_JP.js"(exports, module) {
+    module.exports = require_ja_JP6();
+  }
+});
+export default require_ja_JP7();
+//# sourceMappingURL=antd_locale_ja_JP.js.map

web/node_modules/.vite/deps/antd_locale_zh_CN.js

@@ -0,0 +1,310 @@
+import {
+  require_common
+} from "./chunk-Y4UKYHFZ.js";
+import {
+  require_interopRequireDefault,
+  require_objectSpread2
+} from "./chunk-O3TGDUAO.js";
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/rc-pagination/lib/locale/zh_CN.js
+var require_zh_CN = __commonJS({
+  "node_modules/rc-pagination/lib/locale/zh_CN.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      // Options
+      items_per_page: "条/页",
+      jump_to: "跳至",
+      jump_to_confirm: "确定",
+      page: "页",
+      // Pagination
+      prev_page: "上一页",
+      next_page: "下一页",
+      prev_5: "向前 5 页",
+      next_5: "向后 5 页",
+      prev_3: "向前 3 页",
+      next_3: "向后 3 页",
+      page_size: "页码"
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/rc-picker/lib/locale/zh_CN.js
+var require_zh_CN2 = __commonJS({
+  "node_modules/rc-picker/lib/locale/zh_CN.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _objectSpread2 = _interopRequireDefault(require_objectSpread2());
+    var _common = require_common();
+    var locale = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _common.commonLocale), {}, {
+      locale: "zh_CN",
+      today: "今天",
+      now: "此刻",
+      backToToday: "返回今天",
+      ok: "确定",
+      timeSelect: "选择时间",
+      dateSelect: "选择日期",
+      weekSelect: "选择周",
+      clear: "清除",
+      week: "周",
+      month: "月",
+      year: "年",
+      previousMonth: "上个月 (翻页上键)",
+      nextMonth: "下个月 (翻页下键)",
+      monthSelect: "选择月份",
+      yearSelect: "选择年份",
+      decadeSelect: "选择年代",
+      previousYear: "上一年 (Control键加左方向键)",
+      nextYear: "下一年 (Control键加右方向键)",
+      previousDecade: "上一年代",
+      nextDecade: "下一年代",
+      previousCentury: "上一世纪",
+      nextCentury: "下一世纪",
+      yearFormat: "YYYY年",
+      cellDateFormat: "D",
+      monthBeforeYear: false
+    });
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/time-picker/locale/zh_CN.js
+var require_zh_CN3 = __commonJS({
+  "node_modules/antd/lib/time-picker/locale/zh_CN.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      placeholder: "请选择时间",
+      rangePlaceholder: ["开始时间", "结束时间"]
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/date-picker/locale/zh_CN.js
+var require_zh_CN4 = __commonJS({
+  "node_modules/antd/lib/date-picker/locale/zh_CN.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_CN = _interopRequireDefault(require_zh_CN2());
+    var _zh_CN2 = _interopRequireDefault(require_zh_CN3());
+    var locale = {
+      lang: Object.assign({
+        placeholder: "请选择日期",
+        yearPlaceholder: "请选择年份",
+        quarterPlaceholder: "请选择季度",
+        monthPlaceholder: "请选择月份",
+        weekPlaceholder: "请选择周",
+        rangePlaceholder: ["开始日期", "结束日期"],
+        rangeYearPlaceholder: ["开始年份", "结束年份"],
+        rangeMonthPlaceholder: ["开始月份", "结束月份"],
+        rangeQuarterPlaceholder: ["开始季度", "结束季度"],
+        rangeWeekPlaceholder: ["开始周", "结束周"]
+      }, _zh_CN.default),
+      timePickerLocale: Object.assign({}, _zh_CN2.default)
+    };
+    locale.lang.ok = "确定";
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/calendar/locale/zh_CN.js
+var require_zh_CN5 = __commonJS({
+  "node_modules/antd/lib/calendar/locale/zh_CN.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_CN = _interopRequireDefault(require_zh_CN4());
+    var _default = exports.default = _zh_CN.default;
+  }
+});
+
+// node_modules/antd/lib/locale/zh_CN.js
+var require_zh_CN6 = __commonJS({
+  "node_modules/antd/lib/locale/zh_CN.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_CN = _interopRequireDefault(require_zh_CN());
+    var _zh_CN2 = _interopRequireDefault(require_zh_CN5());
+    var _zh_CN3 = _interopRequireDefault(require_zh_CN4());
+    var _zh_CN4 = _interopRequireDefault(require_zh_CN3());
+    var typeTemplate = "${label}不是一个有效的${type}";
+    var localeValues = {
+      locale: "zh-cn",
+      Pagination: _zh_CN.default,
+      DatePicker: _zh_CN3.default,
+      TimePicker: _zh_CN4.default,
+      Calendar: _zh_CN2.default,
+      // locales for all components
+      global: {
+        placeholder: "请选择",
+        close: "关闭"
+      },
+      Table: {
+        filterTitle: "筛选",
+        filterConfirm: "确定",
+        filterReset: "重置",
+        filterEmptyText: "无筛选项",
+        filterCheckAll: "全选",
+        filterSearchPlaceholder: "在筛选项中搜索",
+        emptyText: "暂无数据",
+        selectAll: "全选当页",
+        selectInvert: "反选当页",
+        selectNone: "清空所有",
+        selectionAll: "全选所有",
+        sortTitle: "排序",
+        expand: "展开行",
+        collapse: "关闭行",
+        triggerDesc: "点击降序",
+        triggerAsc: "点击升序",
+        cancelSort: "取消排序"
+      },
+      Modal: {
+        okText: "确定",
+        cancelText: "取消",
+        justOkText: "知道了"
+      },
+      Tour: {
+        Next: "下一步",
+        Previous: "上一步",
+        Finish: "结束导览"
+      },
+      Popconfirm: {
+        cancelText: "取消",
+        okText: "确定"
+      },
+      Transfer: {
+        titles: ["", ""],
+        searchPlaceholder: "请输入搜索内容",
+        itemUnit: "项",
+        itemsUnit: "项",
+        remove: "删除",
+        selectCurrent: "全选当页",
+        removeCurrent: "删除当页",
+        selectAll: "全选所有",
+        deselectAll: "取消全选",
+        removeAll: "删除全部",
+        selectInvert: "反选当页"
+      },
+      Upload: {
+        uploading: "文件上传中",
+        removeFile: "删除文件",
+        uploadError: "上传错误",
+        previewFile: "预览文件",
+        downloadFile: "下载文件"
+      },
+      Empty: {
+        description: "暂无数据"
+      },
+      Icon: {
+        icon: "图标"
+      },
+      Text: {
+        edit: "编辑",
+        copy: "复制",
+        copied: "复制成功",
+        expand: "展开",
+        collapse: "收起"
+      },
+      Form: {
+        optional: "（可选）",
+        defaultValidateMessages: {
+          default: "字段验证错误${label}",
+          required: "请输入${label}",
+          enum: "${label}必须是其中一个[${enum}]",
+          whitespace: "${label}不能为空字符",
+          date: {
+            format: "${label}日期格式无效",
+            parse: "${label}不能转换为日期",
+            invalid: "${label}是一个无效日期"
+          },
+          types: {
+            string: typeTemplate,
+            method: typeTemplate,
+            array: typeTemplate,
+            object: typeTemplate,
+            number: typeTemplate,
+            date: typeTemplate,
+            boolean: typeTemplate,
+            integer: typeTemplate,
+            float: typeTemplate,
+            regexp: typeTemplate,
+            email: typeTemplate,
+            url: typeTemplate,
+            hex: typeTemplate
+          },
+          string: {
+            len: "${label}须为${len}个字符",
+            min: "${label}最少${min}个字符",
+            max: "${label}最多${max}个字符",
+            range: "${label}须在${min}-${max}字符之间"
+          },
+          number: {
+            len: "${label}必须等于${len}",
+            min: "${label}最小值为${min}",
+            max: "${label}最大值为${max}",
+            range: "${label}须在${min}-${max}之间"
+          },
+          array: {
+            len: "须为${len}个${label}",
+            min: "最少${min}个${label}",
+            max: "最多${max}个${label}",
+            range: "${label}数量须在${min}-${max}之间"
+          },
+          pattern: {
+            mismatch: "${label}与模式不匹配${pattern}"
+          }
+        }
+      },
+      Image: {
+        preview: "预览"
+      },
+      QRCode: {
+        expired: "二维码过期",
+        refresh: "点击刷新",
+        scanned: "已扫描"
+      },
+      ColorPicker: {
+        presetEmpty: "暂无",
+        transparent: "无色",
+        singleColor: "单色",
+        gradientColor: "渐变色"
+      }
+    };
+    var _default = exports.default = localeValues;
+  }
+});
+
+// node_modules/antd/locale/zh_CN.js
+var require_zh_CN7 = __commonJS({
+  "node_modules/antd/locale/zh_CN.js"(exports, module) {
+    module.exports = require_zh_CN6();
+  }
+});
+export default require_zh_CN7();
+//# sourceMappingURL=antd_locale_zh_CN.js.map

web/node_modules/.vite/deps/antd_locale_zh_TW.js

@@ -0,0 +1,310 @@
+import {
+  require_common
+} from "./chunk-Y4UKYHFZ.js";
+import {
+  require_interopRequireDefault,
+  require_objectSpread2
+} from "./chunk-O3TGDUAO.js";
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/rc-pagination/lib/locale/zh_TW.js
+var require_zh_TW = __commonJS({
+  "node_modules/rc-pagination/lib/locale/zh_TW.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      // Options
+      items_per_page: "條/頁",
+      jump_to: "跳至",
+      jump_to_confirm: "確定",
+      page: "頁",
+      // Pagination
+      prev_page: "上一頁",
+      next_page: "下一頁",
+      prev_5: "向前 5 頁",
+      next_5: "向後 5 頁",
+      prev_3: "向前 3 頁",
+      next_3: "向後 3 頁",
+      page_size: "頁碼"
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/rc-picker/lib/locale/zh_TW.js
+var require_zh_TW2 = __commonJS({
+  "node_modules/rc-picker/lib/locale/zh_TW.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _objectSpread2 = _interopRequireDefault(require_objectSpread2());
+    var _common = require_common();
+    var locale = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _common.commonLocale), {}, {
+      locale: "zh_TW",
+      today: "今天",
+      now: "此刻",
+      backToToday: "返回今天",
+      ok: "確定",
+      timeSelect: "選擇時間",
+      dateSelect: "選擇日期",
+      weekSelect: "選擇周",
+      clear: "清除",
+      week: "週",
+      month: "月",
+      year: "年",
+      previousMonth: "上個月 (翻頁上鍵)",
+      nextMonth: "下個月 (翻頁下鍵)",
+      monthSelect: "選擇月份",
+      yearSelect: "選擇年份",
+      decadeSelect: "選擇年代",
+      yearFormat: "YYYY年",
+      dateFormat: "YYYY年M月D日",
+      dateTimeFormat: "YYYY年M月D日 HH時mm分ss秒",
+      previousYear: "上一年 (Control鍵加左方向鍵)",
+      nextYear: "下一年 (Control鍵加右方向鍵)",
+      previousDecade: "上一年代",
+      nextDecade: "下一年代",
+      previousCentury: "上一世紀",
+      nextCentury: "下一世紀",
+      cellDateFormat: "D",
+      monthBeforeYear: false
+    });
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/time-picker/locale/zh_TW.js
+var require_zh_TW3 = __commonJS({
+  "node_modules/antd/lib/time-picker/locale/zh_TW.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var locale = {
+      placeholder: "請選擇時間",
+      rangePlaceholder: ["開始時間", "結束時間"]
+    };
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/date-picker/locale/zh_TW.js
+var require_zh_TW4 = __commonJS({
+  "node_modules/antd/lib/date-picker/locale/zh_TW.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_TW = _interopRequireDefault(require_zh_TW2());
+    var _zh_TW2 = _interopRequireDefault(require_zh_TW3());
+    var locale = {
+      lang: Object.assign({
+        placeholder: "請選擇日期",
+        yearPlaceholder: "請選擇年份",
+        quarterPlaceholder: "請選擇季度",
+        monthPlaceholder: "請選擇月份",
+        weekPlaceholder: "請選擇周",
+        rangePlaceholder: ["開始日期", "結束日期"],
+        rangeYearPlaceholder: ["開始年份", "結束年份"],
+        rangeMonthPlaceholder: ["開始月份", "結束月份"],
+        rangeQuarterPlaceholder: ["開始季度", "結束季度"],
+        rangeWeekPlaceholder: ["開始周", "結束周"]
+      }, _zh_TW.default),
+      timePickerLocale: Object.assign({}, _zh_TW2.default)
+    };
+    locale.lang.ok = "確 定";
+    var _default = exports.default = locale;
+  }
+});
+
+// node_modules/antd/lib/calendar/locale/zh_TW.js
+var require_zh_TW5 = __commonJS({
+  "node_modules/antd/lib/calendar/locale/zh_TW.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_TW = _interopRequireDefault(require_zh_TW4());
+    var _default = exports.default = _zh_TW.default;
+  }
+});
+
+// node_modules/antd/lib/locale/zh_TW.js
+var require_zh_TW6 = __commonJS({
+  "node_modules/antd/lib/locale/zh_TW.js"(exports) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault().default;
+    Object.defineProperty(exports, "__esModule", {
+      value: true
+    });
+    exports.default = void 0;
+    var _zh_TW = _interopRequireDefault(require_zh_TW());
+    var _zh_TW2 = _interopRequireDefault(require_zh_TW5());
+    var _zh_TW3 = _interopRequireDefault(require_zh_TW4());
+    var _zh_TW4 = _interopRequireDefault(require_zh_TW3());
+    var typeTemplate = "${label}不是一個有效的${type}";
+    var localeValues = {
+      locale: "zh-tw",
+      Pagination: _zh_TW.default,
+      DatePicker: _zh_TW3.default,
+      TimePicker: _zh_TW4.default,
+      Calendar: _zh_TW2.default,
+      global: {
+        placeholder: "請選擇",
+        close: "關閉"
+      },
+      Table: {
+        filterTitle: "篩選器",
+        filterConfirm: "確定",
+        filterReset: "重置",
+        filterEmptyText: "無篩選項",
+        filterCheckAll: "全選",
+        filterSearchPlaceholder: "在篩選項中搜尋",
+        emptyText: "暫無數據",
+        selectAll: "全部選取",
+        selectInvert: "反向選取",
+        selectNone: "清空所有",
+        selectionAll: "全選所有",
+        sortTitle: "排序",
+        expand: "展開行",
+        collapse: "關閉行",
+        triggerDesc: "點擊降序",
+        triggerAsc: "點擊升序",
+        cancelSort: "取消排序"
+      },
+      Modal: {
+        okText: "確定",
+        cancelText: "取消",
+        justOkText: "知道了"
+      },
+      Tour: {
+        Next: "下一步",
+        Previous: "上一步",
+        Finish: "結束導覽"
+      },
+      Popconfirm: {
+        okText: "確定",
+        cancelText: "取消"
+      },
+      Transfer: {
+        titles: ["", ""],
+        searchPlaceholder: "搜尋資料",
+        itemUnit: "項目",
+        itemsUnit: "項目",
+        remove: "删除",
+        selectCurrent: "全選當頁",
+        removeCurrent: "删除當頁",
+        selectAll: "全選所有",
+        removeAll: "删除全部",
+        selectInvert: "反選當頁"
+      },
+      Upload: {
+        uploading: "正在上傳...",
+        removeFile: "刪除檔案",
+        uploadError: "上傳失敗",
+        previewFile: "檔案預覽",
+        downloadFile: "下载文件"
+      },
+      Empty: {
+        description: "無此資料"
+      },
+      Icon: {
+        icon: "圖標"
+      },
+      Text: {
+        edit: "編輯",
+        copy: "複製",
+        copied: "複製成功",
+        expand: "展開",
+        collapse: "收起"
+      },
+      Form: {
+        optional: "（可選）",
+        defaultValidateMessages: {
+          default: "字段驗證錯誤${label}",
+          required: "請輸入${label}",
+          enum: "${label}必須是其中一個[${enum}]",
+          whitespace: "${label}不能為空字符",
+          date: {
+            format: "${label}日期格式無效",
+            parse: "${label}不能轉換為日期",
+            invalid: "${label}是一個無效日期"
+          },
+          types: {
+            string: typeTemplate,
+            method: typeTemplate,
+            array: typeTemplate,
+            object: typeTemplate,
+            number: typeTemplate,
+            date: typeTemplate,
+            boolean: typeTemplate,
+            integer: typeTemplate,
+            float: typeTemplate,
+            regexp: typeTemplate,
+            email: typeTemplate,
+            url: typeTemplate,
+            hex: typeTemplate
+          },
+          string: {
+            len: "${label}須為${len}個字符",
+            min: "${label}最少${min}個字符",
+            max: "${label}最多${max}個字符",
+            range: "${label}須在${min}-${max}字符之間"
+          },
+          number: {
+            len: "${label}必須等於${len}",
+            min: "${label}最小值為${min}",
+            max: "${label}最大值為${max}",
+            range: "${label}須在${min}-${max}之間"
+          },
+          array: {
+            len: "須為${len}個${label}",
+            min: "最少${min}個${label}",
+            max: "最多${max}個${label}",
+            range: "${label}數量須在${min}-${max}之間"
+          },
+          pattern: {
+            mismatch: "${label}與模式不匹配${pattern}"
+          }
+        }
+      },
+      Image: {
+        preview: "預覽"
+      },
+      QRCode: {
+        expired: "二維碼過期",
+        refresh: "點擊刷新",
+        scanned: "已掃描"
+      },
+      ColorPicker: {
+        presetEmpty: "暫無",
+        transparent: "透明",
+        singleColor: "單色",
+        gradientColor: "漸變色"
+      }
+    };
+    var _default = exports.default = localeValues;
+  }
+});
+
+// node_modules/antd/locale/zh_TW.js
+var require_zh_TW7 = __commonJS({
+  "node_modules/antd/locale/zh_TW.js"(exports, module) {
+    module.exports = require_zh_TW6();
+  }
+});
+export default require_zh_TW7();
+//# sourceMappingURL=antd_locale_zh_TW.js.map

web/node_modules/.vite/deps/apex-XVBKQMXD.js

@@ -0,0 +1,335 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/apex/apex.js
+var conf = {
+  // the default separators except `@$`
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' },
+    { open: "'", close: "'" },
+    { open: "<", close: ">" }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*//\\s*(?:(?:#?region\\b)|(?:<editor-fold\\b))"),
+      end: new RegExp("^\\s*//\\s*(?:(?:#?endregion\\b)|(?:</editor-fold>))")
+    }
+  }
+};
+var keywords = [
+  "abstract",
+  "activate",
+  "and",
+  "any",
+  "array",
+  "as",
+  "asc",
+  "assert",
+  "autonomous",
+  "begin",
+  "bigdecimal",
+  "blob",
+  "boolean",
+  "break",
+  "bulk",
+  "by",
+  "case",
+  "cast",
+  "catch",
+  "char",
+  "class",
+  "collect",
+  "commit",
+  "const",
+  "continue",
+  "convertcurrency",
+  "decimal",
+  "default",
+  "delete",
+  "desc",
+  "do",
+  "double",
+  "else",
+  "end",
+  "enum",
+  "exception",
+  "exit",
+  "export",
+  "extends",
+  "false",
+  "final",
+  "finally",
+  "float",
+  "for",
+  "from",
+  "future",
+  "get",
+  "global",
+  "goto",
+  "group",
+  "having",
+  "hint",
+  "if",
+  "implements",
+  "import",
+  "in",
+  "inner",
+  "insert",
+  "instanceof",
+  "int",
+  "interface",
+  "into",
+  "join",
+  "last_90_days",
+  "last_month",
+  "last_n_days",
+  "last_week",
+  "like",
+  "limit",
+  "list",
+  "long",
+  "loop",
+  "map",
+  "merge",
+  "native",
+  "new",
+  "next_90_days",
+  "next_month",
+  "next_n_days",
+  "next_week",
+  "not",
+  "null",
+  "nulls",
+  "number",
+  "object",
+  "of",
+  "on",
+  "or",
+  "outer",
+  "override",
+  "package",
+  "parallel",
+  "pragma",
+  "private",
+  "protected",
+  "public",
+  "retrieve",
+  "return",
+  "returning",
+  "rollback",
+  "savepoint",
+  "search",
+  "select",
+  "set",
+  "short",
+  "sort",
+  "stat",
+  "static",
+  "strictfp",
+  "super",
+  "switch",
+  "synchronized",
+  "system",
+  "testmethod",
+  "then",
+  "this",
+  "this_month",
+  "this_week",
+  "throw",
+  "throws",
+  "today",
+  "tolabel",
+  "tomorrow",
+  "transaction",
+  "transient",
+  "trigger",
+  "true",
+  "try",
+  "type",
+  "undelete",
+  "update",
+  "upsert",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "webservice",
+  "when",
+  "where",
+  "while",
+  "yesterday"
+];
+var uppercaseFirstLetter = (lowercase) => lowercase.charAt(0).toUpperCase() + lowercase.substr(1);
+var keywordsWithCaseVariations = [];
+keywords.forEach((lowercase) => {
+  keywordsWithCaseVariations.push(lowercase);
+  keywordsWithCaseVariations.push(lowercase.toUpperCase());
+  keywordsWithCaseVariations.push(uppercaseFirstLetter(lowercase));
+});
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".apex",
+  keywords: keywordsWithCaseVariations,
+  operators: [
+    "=",
+    ">",
+    "<",
+    "!",
+    "~",
+    "?",
+    ":",
+    "==",
+    "<=",
+    ">=",
+    "!=",
+    "&&",
+    "||",
+    "++",
+    "--",
+    "+",
+    "-",
+    "*",
+    "/",
+    "&",
+    "|",
+    "^",
+    "%",
+    "<<",
+    ">>",
+    ">>>",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "&=",
+    "|=",
+    "^=",
+    "%=",
+    "<<=",
+    ">>=",
+    ">>>="
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // identifiers and keywords
+      [
+        /[a-z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // assume that identifiers starting with an uppercase letter are types
+      [
+        /[A-Z][\w\$]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "type.identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // @ annotations.
+      [/@\s*[a-zA-Z_\$][\w\$]*/, "annotation"],
+      // numbers
+      [/(@digits)[eE]([\-+]?(@digits))?[fFdD]?/, "number.float"],
+      [/(@digits)\.(@digits)([eE][\-+]?(@digits))?[fFdD]?/, "number.float"],
+      [/(@digits)[fFdD]/, "number.float"],
+      [/(@digits)[lL]?/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, "string", '@string."'],
+      [/'/, "string", "@string.'"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/(')(@escapes)(')/, ["string", "string.escape", "string"]],
+      [/'/, "string.invalid"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@apexdoc"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      // [/\/\*/, 'comment', '@push' ],    // nested comment not allowed :-(
+      // [/\/\*/,    'comment.invalid' ],    // this breaks block comments in the shape of /* //*/
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    //Identical copy of comment above, except for the addition of .doc
+    apexdoc: [
+      [/[^\/*]+/, "comment.doc"],
+      [/\*\//, "comment.doc", "@pop"],
+      [/[\/*]/, "comment.doc"]
+    ],
+    string: [
+      [/[^\\"']+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=apex-XVBKQMXD.js.map

web/node_modules/.vite/deps/azcli-GM3WENR2.js

@@ -0,0 +1,73 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/azcli/azcli.js
+var conf = {
+  comments: {
+    lineComment: "#"
+  }
+};
+var language = {
+  defaultToken: "keyword",
+  ignoreCase: true,
+  tokenPostfix: ".azcli",
+  str: /[^#\s]/,
+  tokenizer: {
+    root: [
+      { include: "@comment" },
+      [
+        /\s-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": { token: "key.identifier", next: "@type" }
+          }
+        }
+      ],
+      [
+        /^-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": { token: "key.identifier", next: "@type" }
+          }
+        }
+      ]
+    ],
+    type: [
+      { include: "@comment" },
+      [
+        /-+@str*\s*/,
+        {
+          cases: {
+            "@eos": { token: "key.identifier", next: "@popall" },
+            "@default": "key.identifier"
+          }
+        }
+      ],
+      [
+        /@str+\s*/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ]
+    ],
+    comment: [
+      [
+        /#.*$/,
+        {
+          cases: {
+            "@eos": { token: "comment", next: "@popall" }
+          }
+        }
+      ]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=azcli-GM3WENR2.js.map

web/node_modules/.vite/deps/azcli-GM3WENR2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../monaco-editor/esm/vs/basic-languages/azcli/azcli.js"],
+  "sourcesContent": ["const conf = {\n  comments: {\n    lineComment: \"#\"\n  }\n};\nconst language = {\n  defaultToken: \"keyword\",\n  ignoreCase: true,\n  tokenPostfix: \".azcli\",\n  str: /[^#\\s]/,\n  tokenizer: {\n    root: [\n      { include: \"@comment\" },\n      [\n        /\\s-+@str*\\s*/,\n        {\n          cases: {\n            \"@eos\": { token: \"key.identifier\", next: \"@popall\" },\n            \"@default\": { token: \"key.identifier\", next: \"@type\" }\n          }\n        }\n      ],\n      [\n        /^-+@str*\\s*/,\n        {\n          cases: {\n            \"@eos\": { token: \"key.identifier\", next: \"@popall\" },\n            \"@default\": { token: \"key.identifier\", next: \"@type\" }\n          }\n        }\n      ]\n    ],\n    type: [\n      { include: \"@comment\" },\n      [\n        /-+@str*\\s*/,\n        {\n          cases: {\n            \"@eos\": { token: \"key.identifier\", next: \"@popall\" },\n            \"@default\": \"key.identifier\"\n          }\n        }\n      ],\n      [\n        /@str+\\s*/,\n        {\n          cases: {\n            \"@eos\": { token: \"string\", next: \"@popall\" },\n            \"@default\": \"string\"\n          }\n        }\n      ]\n    ],\n    comment: [\n      [\n        /#.*$/,\n        {\n          cases: {\n            \"@eos\": { token: \"comment\", next: \"@popall\" }\n          }\n        }\n      ]\n    ]\n  }\n};\n\nexport { conf, language };\n"],
+  "mappings": ";;;AAAA,IAAM,OAAO;AAAA,EACX,UAAU;AAAA,IACR,aAAa;AAAA,EACf;AACF;AACA,IAAM,WAAW;AAAA,EACf,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,KAAK;AAAA,EACL,WAAW;AAAA,IACT,MAAM;AAAA,MACJ,EAAE,SAAS,WAAW;AAAA,MACtB;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,kBAAkB,MAAM,UAAU;AAAA,YACnD,YAAY,EAAE,OAAO,kBAAkB,MAAM,QAAQ;AAAA,UACvD;AAAA,QACF;AAAA,MACF;AAAA,MACA;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,kBAAkB,MAAM,UAAU;AAAA,YACnD,YAAY,EAAE,OAAO,kBAAkB,MAAM,QAAQ;AAAA,UACvD;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,MAAM;AAAA,MACJ,EAAE,SAAS,WAAW;AAAA,MACtB;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,kBAAkB,MAAM,UAAU;AAAA,YACnD,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA,MACA;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,UAAU,MAAM,UAAU;AAAA,YAC3C,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,IACA,SAAS;AAAA,MACP;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,WAAW,MAAM,UAAU;AAAA,UAC9C;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

web/node_modules/.vite/deps/bat-F5HQNANB.js

@@ -0,0 +1,105 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/bat/bat.js
+var conf = {
+  comments: {
+    lineComment: "REM"
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' }
+  ],
+  surroundingPairs: [
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"' }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*(::\\s*|REM\\s+)#region"),
+      end: new RegExp("^\\s*(::\\s*|REM\\s+)#endregion")
+    }
+  }
+};
+var language = {
+  defaultToken: "",
+  ignoreCase: true,
+  tokenPostfix: ".bat",
+  brackets: [
+    { token: "delimiter.bracket", open: "{", close: "}" },
+    { token: "delimiter.parenthesis", open: "(", close: ")" },
+    { token: "delimiter.square", open: "[", close: "]" }
+  ],
+  keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,
+  // we include these common regular expressions
+  symbols: /[=><!~?&|+\-*\/\^;\.,]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      [/^(\s*)(rem(?:\s.*|))$/, ["", "comment"]],
+      [/(\@?)(@keywords)(?!\w)/, [{ token: "keyword" }, { token: "keyword.$2" }]],
+      // whitespace
+      [/[ \t\r\n]+/, ""],
+      // blocks
+      [/setlocal(?!\w)/, "keyword.tag-setlocal"],
+      [/endlocal(?!\w)/, "keyword.tag-setlocal"],
+      // words
+      [/[a-zA-Z_]\w*/, ""],
+      // labels
+      [/:\w*/, "metatag"],
+      // variables
+      [/%[^%]+%/, "variable"],
+      [/%%[\w]+(?!\w)/, "variable"],
+      // punctuations
+      [/[{}()\[\]]/, "@brackets"],
+      [/@symbols/, "delimiter"],
+      // numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, "number.hex"],
+      [/\d+/, "number"],
+      // punctuation: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings:
+      [/"/, "string", '@string."'],
+      [/'/, "string", "@string.'"]
+    ],
+    string: [
+      [
+        /[^\\"'%]+/,
+        {
+          cases: {
+            "@eos": { token: "string", next: "@popall" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/%[\w ]+%/, "variable"],
+      [/%%[\w]+(?!\w)/, "variable"],
+      [
+        /["']/,
+        {
+          cases: {
+            "$#==$S2": { token: "string", next: "@pop" },
+            "@default": "string"
+          }
+        }
+      ],
+      [/$/, "string", "@popall"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=bat-F5HQNANB.js.map

web/node_modules/.vite/deps/bat-F5HQNANB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../monaco-editor/esm/vs/basic-languages/bat/bat.js"],
+  "sourcesContent": ["const conf = {\n  comments: {\n    lineComment: \"REM\"\n  },\n  brackets: [\n    [\"{\", \"}\"],\n    [\"[\", \"]\"],\n    [\"(\", \")\"]\n  ],\n  autoClosingPairs: [\n    { open: \"{\", close: \"}\" },\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: '\"', close: '\"' }\n  ],\n  surroundingPairs: [\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: '\"', close: '\"' }\n  ],\n  folding: {\n    markers: {\n      start: new RegExp(\"^\\\\s*(::\\\\s*|REM\\\\s+)#region\"),\n      end: new RegExp(\"^\\\\s*(::\\\\s*|REM\\\\s+)#endregion\")\n    }\n  }\n};\nconst language = {\n  defaultToken: \"\",\n  ignoreCase: true,\n  tokenPostfix: \".bat\",\n  brackets: [\n    { token: \"delimiter.bracket\", open: \"{\", close: \"}\" },\n    { token: \"delimiter.parenthesis\", open: \"(\", close: \")\" },\n    { token: \"delimiter.square\", open: \"[\", close: \"]\" }\n  ],\n  keywords: /call|defined|echo|errorlevel|exist|for|goto|if|pause|set|shift|start|title|not|pushd|popd/,\n  // we include these common regular expressions\n  symbols: /[=><!~?&|+\\-*\\/\\^;\\.,]+/,\n  escapes: /\\\\(?:[abfnrtv\\\\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,\n  // The main tokenizer for our languages\n  tokenizer: {\n    root: [\n      [/^(\\s*)(rem(?:\\s.*|))$/, [\"\", \"comment\"]],\n      [/(\\@?)(@keywords)(?!\\w)/, [{ token: \"keyword\" }, { token: \"keyword.$2\" }]],\n      // whitespace\n      [/[ \\t\\r\\n]+/, \"\"],\n      // blocks\n      [/setlocal(?!\\w)/, \"keyword.tag-setlocal\"],\n      [/endlocal(?!\\w)/, \"keyword.tag-setlocal\"],\n      // words\n      [/[a-zA-Z_]\\w*/, \"\"],\n      // labels\n      [/:\\w*/, \"metatag\"],\n      // variables\n      [/%[^%]+%/, \"variable\"],\n      [/%%[\\w]+(?!\\w)/, \"variable\"],\n      // punctuations\n      [/[{}()\\[\\]]/, \"@brackets\"],\n      [/@symbols/, \"delimiter\"],\n      // numbers\n      [/\\d*\\.\\d+([eE][\\-+]?\\d+)?/, \"number.float\"],\n      [/0[xX][0-9a-fA-F_]*[0-9a-fA-F]/, \"number.hex\"],\n      [/\\d+/, \"number\"],\n      // punctuation: after number because of .\\d floats\n      [/[;,.]/, \"delimiter\"],\n      // strings:\n      [/\"/, \"string\", '@string.\"'],\n      [/'/, \"string\", \"@string.'\"]\n    ],\n    string: [\n      [\n        /[^\\\\\"'%]+/,\n        {\n          cases: {\n            \"@eos\": { token: \"string\", next: \"@popall\" },\n            \"@default\": \"string\"\n          }\n        }\n      ],\n      [/@escapes/, \"string.escape\"],\n      [/\\\\./, \"string.escape.invalid\"],\n      [/%[\\w ]+%/, \"variable\"],\n      [/%%[\\w]+(?!\\w)/, \"variable\"],\n      [\n        /[\"']/,\n        {\n          cases: {\n            \"$#==$S2\": { token: \"string\", next: \"@pop\" },\n            \"@default\": \"string\"\n          }\n        }\n      ],\n      [/$/, \"string\", \"@popall\"]\n    ]\n  }\n};\n\nexport { conf, language };\n"],
+  "mappings": ";;;AAAA,IAAM,OAAO;AAAA,EACX,UAAU;AAAA,IACR,aAAa;AAAA,EACf;AAAA,EACA,UAAU;AAAA,IACR,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,EACX;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,EAC1B;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,EAC1B;AAAA,EACA,SAAS;AAAA,IACP,SAAS;AAAA,MACP,OAAO,IAAI,OAAO,8BAA8B;AAAA,MAChD,KAAK,IAAI,OAAO,iCAAiC;AAAA,IACnD;AAAA,EACF;AACF;AACA,IAAM,WAAW;AAAA,EACf,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,UAAU;AAAA,IACR,EAAE,OAAO,qBAAqB,MAAM,KAAK,OAAO,IAAI;AAAA,IACpD,EAAE,OAAO,yBAAyB,MAAM,KAAK,OAAO,IAAI;AAAA,IACxD,EAAE,OAAO,oBAAoB,MAAM,KAAK,OAAO,IAAI;AAAA,EACrD;AAAA,EACA,UAAU;AAAA;AAAA,EAEV,SAAS;AAAA,EACT,SAAS;AAAA;AAAA,EAET,WAAW;AAAA,IACT,MAAM;AAAA,MACJ,CAAC,yBAAyB,CAAC,IAAI,SAAS,CAAC;AAAA,MACzC,CAAC,0BAA0B,CAAC,EAAE,OAAO,UAAU,GAAG,EAAE,OAAO,aAAa,CAAC,CAAC;AAAA;AAAA,MAE1E,CAAC,cAAc,EAAE;AAAA;AAAA,MAEjB,CAAC,kBAAkB,sBAAsB;AAAA,MACzC,CAAC,kBAAkB,sBAAsB;AAAA;AAAA,MAEzC,CAAC,gBAAgB,EAAE;AAAA;AAAA,MAEnB,CAAC,QAAQ,SAAS;AAAA;AAAA,MAElB,CAAC,WAAW,UAAU;AAAA,MACtB,CAAC,iBAAiB,UAAU;AAAA;AAAA,MAE5B,CAAC,cAAc,WAAW;AAAA,MAC1B,CAAC,YAAY,WAAW;AAAA;AAAA,MAExB,CAAC,4BAA4B,cAAc;AAAA,MAC3C,CAAC,iCAAiC,YAAY;AAAA,MAC9C,CAAC,OAAO,QAAQ;AAAA;AAAA,MAEhB,CAAC,SAAS,WAAW;AAAA;AAAA,MAErB,CAAC,KAAK,UAAU,WAAW;AAAA,MAC3B,CAAC,KAAK,UAAU,WAAW;AAAA,IAC7B;AAAA,IACA,QAAQ;AAAA,MACN;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,QAAQ,EAAE,OAAO,UAAU,MAAM,UAAU;AAAA,YAC3C,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA,MACA,CAAC,YAAY,eAAe;AAAA,MAC5B,CAAC,OAAO,uBAAuB;AAAA,MAC/B,CAAC,YAAY,UAAU;AAAA,MACvB,CAAC,iBAAiB,UAAU;AAAA,MAC5B;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,WAAW,EAAE,OAAO,UAAU,MAAM,OAAO;AAAA,YAC3C,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA,MACA,CAAC,KAAK,UAAU,SAAS;AAAA,IAC3B;AAAA,EACF;AACF;",
+  "names": []
+}

web/node_modules/.vite/deps/bicep-KHSV6VEI.js

@@ -0,0 +1,114 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/bicep/bicep.js
+var bounded = (text) => `\\b${text}\\b`;
+var identifierStart = "[_a-zA-Z]";
+var identifierContinue = "[_a-zA-Z0-9]";
+var identifier = bounded(`${identifierStart}${identifierContinue}*`);
+var keywords = [
+  "targetScope",
+  "resource",
+  "module",
+  "param",
+  "var",
+  "output",
+  "for",
+  "in",
+  "if",
+  "existing"
+];
+var namedLiterals = ["true", "false", "null"];
+var nonCommentWs = `[ \\t\\r\\n]`;
+var numericLiteral = `[0-9]+`;
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'" },
+    { open: "'''", close: "'''" }
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: "'''", close: "'''", notIn: ["string", "comment"] }
+  ],
+  autoCloseBefore: ":.,=}])' \n	",
+  indentationRules: {
+    increaseIndentPattern: new RegExp("^((?!\\/\\/).)*(\\{[^}\"'`]*|\\([^)\"'`]*|\\[[^\\]\"'`]*)$"),
+    decreaseIndentPattern: new RegExp("^((?!.*?\\/\\*).*\\*/)?\\s*[\\}\\]].*$")
+  }
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".bicep",
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" }
+  ],
+  symbols: /[=><!~?:&|+\-*/^%]+/,
+  keywords,
+  namedLiterals,
+  escapes: `\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\|'|\\\${)`,
+  tokenizer: {
+    root: [{ include: "@expression" }, { include: "@whitespace" }],
+    stringVerbatim: [
+      { regex: `(|'|'')[^']`, action: { token: "string" } },
+      { regex: `'''`, action: { token: "string.quote", next: "@pop" } }
+    ],
+    stringLiteral: [
+      { regex: `\\\${`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+      { regex: `[^\\\\'$]+`, action: { token: "string" } },
+      { regex: "@escapes", action: { token: "string.escape" } },
+      { regex: `\\\\.`, action: { token: "string.escape.invalid" } },
+      { regex: `'`, action: { token: "string", next: "@pop" } }
+    ],
+    bracketCounting: [
+      { regex: `{`, action: { token: "delimiter.bracket", next: "@bracketCounting" } },
+      { regex: `}`, action: { token: "delimiter.bracket", next: "@pop" } },
+      { include: "expression" }
+    ],
+    comment: [
+      { regex: `[^\\*]+`, action: { token: "comment" } },
+      { regex: `\\*\\/`, action: { token: "comment", next: "@pop" } },
+      { regex: `[\\/*]`, action: { token: "comment" } }
+    ],
+    whitespace: [
+      { regex: nonCommentWs },
+      { regex: `\\/\\*`, action: { token: "comment", next: "@comment" } },
+      { regex: `\\/\\/.*$`, action: { token: "comment" } }
+    ],
+    expression: [
+      { regex: `'''`, action: { token: "string.quote", next: "@stringVerbatim" } },
+      { regex: `'`, action: { token: "string.quote", next: "@stringLiteral" } },
+      { regex: numericLiteral, action: { token: "number" } },
+      {
+        regex: identifier,
+        action: {
+          cases: {
+            "@keywords": { token: "keyword" },
+            "@namedLiterals": { token: "keyword" },
+            "@default": { token: "identifier" }
+          }
+        }
+      }
+    ]
+  }
+};
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=bicep-KHSV6VEI.js.map

web/node_modules/.vite/deps/bicep-KHSV6VEI.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../monaco-editor/esm/vs/basic-languages/bicep/bicep.js"],
+  "sourcesContent": ["const bounded = (text) => `\\\\b${text}\\\\b`;\nconst identifierStart = \"[_a-zA-Z]\";\nconst identifierContinue = \"[_a-zA-Z0-9]\";\nconst identifier = bounded(`${identifierStart}${identifierContinue}*`);\nconst keywords = [\n  \"targetScope\",\n  \"resource\",\n  \"module\",\n  \"param\",\n  \"var\",\n  \"output\",\n  \"for\",\n  \"in\",\n  \"if\",\n  \"existing\"\n];\nconst namedLiterals = [\"true\", \"false\", \"null\"];\nconst nonCommentWs = `[ \\\\t\\\\r\\\\n]`;\nconst numericLiteral = `[0-9]+`;\nconst conf = {\n  comments: {\n    lineComment: \"//\",\n    blockComment: [\"/*\", \"*/\"]\n  },\n  brackets: [\n    [\"{\", \"}\"],\n    [\"[\", \"]\"],\n    [\"(\", \")\"]\n  ],\n  surroundingPairs: [\n    { open: \"{\", close: \"}\" },\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: \"'\", close: \"'\" },\n    { open: \"'''\", close: \"'''\" }\n  ],\n  autoClosingPairs: [\n    { open: \"{\", close: \"}\" },\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: \"'\", close: \"'\", notIn: [\"string\", \"comment\"] },\n    { open: \"'''\", close: \"'''\", notIn: [\"string\", \"comment\"] }\n  ],\n  autoCloseBefore: \":.,=}])' \\n\t\",\n  indentationRules: {\n    increaseIndentPattern: new RegExp(\"^((?!\\\\/\\\\/).)*(\\\\{[^}\\\"'`]*|\\\\([^)\\\"'`]*|\\\\[[^\\\\]\\\"'`]*)$\"),\n    decreaseIndentPattern: new RegExp(\"^((?!.*?\\\\/\\\\*).*\\\\*/)?\\\\s*[\\\\}\\\\]].*$\")\n  }\n};\nconst language = {\n  defaultToken: \"\",\n  tokenPostfix: \".bicep\",\n  brackets: [\n    { open: \"{\", close: \"}\", token: \"delimiter.curly\" },\n    { open: \"[\", close: \"]\", token: \"delimiter.square\" },\n    { open: \"(\", close: \")\", token: \"delimiter.parenthesis\" }\n  ],\n  symbols: /[=><!~?:&|+\\-*/^%]+/,\n  keywords,\n  namedLiterals,\n  escapes: `\\\\\\\\(u{[0-9A-Fa-f]+}|n|r|t|\\\\\\\\|'|\\\\\\${)`,\n  tokenizer: {\n    root: [{ include: \"@expression\" }, { include: \"@whitespace\" }],\n    stringVerbatim: [\n      { regex: `(|'|'')[^']`, action: { token: \"string\" } },\n      { regex: `'''`, action: { token: \"string.quote\", next: \"@pop\" } }\n    ],\n    stringLiteral: [\n      { regex: `\\\\\\${`, action: { token: \"delimiter.bracket\", next: \"@bracketCounting\" } },\n      { regex: `[^\\\\\\\\'$]+`, action: { token: \"string\" } },\n      { regex: \"@escapes\", action: { token: \"string.escape\" } },\n      { regex: `\\\\\\\\.`, action: { token: \"string.escape.invalid\" } },\n      { regex: `'`, action: { token: \"string\", next: \"@pop\" } }\n    ],\n    bracketCounting: [\n      { regex: `{`, action: { token: \"delimiter.bracket\", next: \"@bracketCounting\" } },\n      { regex: `}`, action: { token: \"delimiter.bracket\", next: \"@pop\" } },\n      { include: \"expression\" }\n    ],\n    comment: [\n      { regex: `[^\\\\*]+`, action: { token: \"comment\" } },\n      { regex: `\\\\*\\\\/`, action: { token: \"comment\", next: \"@pop\" } },\n      { regex: `[\\\\/*]`, action: { token: \"comment\" } }\n    ],\n    whitespace: [\n      { regex: nonCommentWs },\n      { regex: `\\\\/\\\\*`, action: { token: \"comment\", next: \"@comment\" } },\n      { regex: `\\\\/\\\\/.*$`, action: { token: \"comment\" } }\n    ],\n    expression: [\n      { regex: `'''`, action: { token: \"string.quote\", next: \"@stringVerbatim\" } },\n      { regex: `'`, action: { token: \"string.quote\", next: \"@stringLiteral\" } },\n      { regex: numericLiteral, action: { token: \"number\" } },\n      {\n        regex: identifier,\n        action: {\n          cases: {\n            \"@keywords\": { token: \"keyword\" },\n            \"@namedLiterals\": { token: \"keyword\" },\n            \"@default\": { token: \"identifier\" }\n          }\n        }\n      }\n    ]\n  }\n};\n\nexport { conf, language };\n"],
+  "mappings": ";;;AAAA,IAAM,UAAU,CAAC,SAAS,MAAM,IAAI;AACpC,IAAM,kBAAkB;AACxB,IAAM,qBAAqB;AAC3B,IAAM,aAAa,QAAQ,GAAG,eAAe,GAAG,kBAAkB,GAAG;AACrE,IAAM,WAAW;AAAA,EACf;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AACA,IAAM,gBAAgB,CAAC,QAAQ,SAAS,MAAM;AAC9C,IAAM,eAAe;AACrB,IAAM,iBAAiB;AACvB,IAAM,OAAO;AAAA,EACX,UAAU;AAAA,IACR,aAAa;AAAA,IACb,cAAc,CAAC,MAAM,IAAI;AAAA,EAC3B;AAAA,EACA,UAAU;AAAA,IACR,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,EACX;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,OAAO,OAAO,MAAM;AAAA,EAC9B;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,CAAC,UAAU,SAAS,EAAE;AAAA,IACtD,EAAE,MAAM,OAAO,OAAO,OAAO,OAAO,CAAC,UAAU,SAAS,EAAE;AAAA,EAC5D;AAAA,EACA,iBAAiB;AAAA,EACjB,kBAAkB;AAAA,IAChB,uBAAuB,IAAI,OAAO,4DAA4D;AAAA,IAC9F,uBAAuB,IAAI,OAAO,wCAAwC;AAAA,EAC5E;AACF;AACA,IAAM,WAAW;AAAA,EACf,cAAc;AAAA,EACd,cAAc;AAAA,EACd,UAAU;AAAA,IACR,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,kBAAkB;AAAA,IAClD,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,mBAAmB;AAAA,IACnD,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,wBAAwB;AAAA,EAC1D;AAAA,EACA,SAAS;AAAA,EACT;AAAA,EACA;AAAA,EACA,SAAS;AAAA,EACT,WAAW;AAAA,IACT,MAAM,CAAC,EAAE,SAAS,cAAc,GAAG,EAAE,SAAS,cAAc,CAAC;AAAA,IAC7D,gBAAgB;AAAA,MACd,EAAE,OAAO,eAAe,QAAQ,EAAE,OAAO,SAAS,EAAE;AAAA,MACpD,EAAE,OAAO,OAAO,QAAQ,EAAE,OAAO,gBAAgB,MAAM,OAAO,EAAE;AAAA,IAClE;AAAA,IACA,eAAe;AAAA,MACb,EAAE,OAAO,SAAS,QAAQ,EAAE,OAAO,qBAAqB,MAAM,mBAAmB,EAAE;AAAA,MACnF,EAAE,OAAO,cAAc,QAAQ,EAAE,OAAO,SAAS,EAAE;AAAA,MACnD,EAAE,OAAO,YAAY,QAAQ,EAAE,OAAO,gBAAgB,EAAE;AAAA,MACxD,EAAE,OAAO,SAAS,QAAQ,EAAE,OAAO,wBAAwB,EAAE;AAAA,MAC7D,EAAE,OAAO,KAAK,QAAQ,EAAE,OAAO,UAAU,MAAM,OAAO,EAAE;AAAA,IAC1D;AAAA,IACA,iBAAiB;AAAA,MACf,EAAE,OAAO,KAAK,QAAQ,EAAE,OAAO,qBAAqB,MAAM,mBAAmB,EAAE;AAAA,MAC/E,EAAE,OAAO,KAAK,QAAQ,EAAE,OAAO,qBAAqB,MAAM,OAAO,EAAE;AAAA,MACnE,EAAE,SAAS,aAAa;AAAA,IAC1B;AAAA,IACA,SAAS;AAAA,MACP,EAAE,OAAO,WAAW,QAAQ,EAAE,OAAO,UAAU,EAAE;AAAA,MACjD,EAAE,OAAO,UAAU,QAAQ,EAAE,OAAO,WAAW,MAAM,OAAO,EAAE;AAAA,MAC9D,EAAE,OAAO,UAAU,QAAQ,EAAE,OAAO,UAAU,EAAE;AAAA,IAClD;AAAA,IACA,YAAY;AAAA,MACV,EAAE,OAAO,aAAa;AAAA,MACtB,EAAE,OAAO,UAAU,QAAQ,EAAE,OAAO,WAAW,MAAM,WAAW,EAAE;AAAA,MAClE,EAAE,OAAO,aAAa,QAAQ,EAAE,OAAO,UAAU,EAAE;AAAA,IACrD;AAAA,IACA,YAAY;AAAA,MACV,EAAE,OAAO,OAAO,QAAQ,EAAE,OAAO,gBAAgB,MAAM,kBAAkB,EAAE;AAAA,MAC3E,EAAE,OAAO,KAAK,QAAQ,EAAE,OAAO,gBAAgB,MAAM,iBAAiB,EAAE;AAAA,MACxE,EAAE,OAAO,gBAAgB,QAAQ,EAAE,OAAO,SAAS,EAAE;AAAA,MACrD;AAAA,QACE,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,OAAO;AAAA,YACL,aAAa,EAAE,OAAO,UAAU;AAAA,YAChC,kBAAkB,EAAE,OAAO,UAAU;AAAA,YACrC,YAAY,EAAE,OAAO,aAAa;AAAA,UACpC;AAAA,QACF;AAAA,MACF;AAAA,IACF;AAAA,EACF;AACF;",
+  "names": []
+}

web/node_modules/.vite/deps/cameligo-NOFINCMB.js

@@ -0,0 +1,179 @@
+import "./chunk-V4OQ3NZ2.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/cameligo/cameligo.js
+var conf = {
+  comments: {
+    lineComment: "//",
+    blockComment: ["(*", "*)"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["<", ">"]
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' },
+    { open: "(*", close: "*)" }
+  ],
+  surroundingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: "<", close: ">" },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' },
+    { open: "(*", close: "*)" }
+  ]
+};
+var language = {
+  defaultToken: "",
+  tokenPostfix: ".cameligo",
+  ignoreCase: true,
+  brackets: [
+    { open: "{", close: "}", token: "delimiter.curly" },
+    { open: "[", close: "]", token: "delimiter.square" },
+    { open: "(", close: ")", token: "delimiter.parenthesis" },
+    { open: "<", close: ">", token: "delimiter.angle" }
+  ],
+  keywords: [
+    "abs",
+    "assert",
+    "block",
+    "Bytes",
+    "case",
+    "Crypto",
+    "Current",
+    "else",
+    "failwith",
+    "false",
+    "for",
+    "fun",
+    "if",
+    "in",
+    "let",
+    "let%entry",
+    "let%init",
+    "List",
+    "list",
+    "Map",
+    "map",
+    "match",
+    "match%nat",
+    "mod",
+    "not",
+    "operation",
+    "Operation",
+    "of",
+    "record",
+    "Set",
+    "set",
+    "sender",
+    "skip",
+    "source",
+    "String",
+    "then",
+    "to",
+    "true",
+    "type",
+    "with"
+  ],
+  typeKeywords: ["int", "unit", "string", "tz", "nat", "bool"],
+  operators: [
+    "=",
+    ">",
+    "<",
+    "<=",
+    ">=",
+    "<>",
+    ":",
+    ":=",
+    "and",
+    "mod",
+    "or",
+    "+",
+    "-",
+    "*",
+    "/",
+    "@",
+    "&",
+    "^",
+    "%",
+    "->",
+    "<-",
+    "&&",
+    "||"
+  ],
+  // we include these common regular expressions
+  symbols: /[=><:@\^&|+\-*\/\^%]+/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [
+      // identifiers and keywords
+      [
+        /[a-zA-Z_][\w]*/,
+        {
+          cases: {
+            "@keywords": { token: "keyword.$0" },
+            "@default": "identifier"
+          }
+        }
+      ],
+      // whitespace
+      { include: "@whitespace" },
+      // delimiters and operators
+      [/[{}()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, "number.float"],
+      [/\$[0-9a-fA-F]{1,16}/, "number.hex"],
+      [/\d+/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/'/, "string", "@string"],
+      // characters
+      [/'[^\\']'/, "string"],
+      [/'/, "string.invalid"],
+      [/\#\d+/, "string"]
+    ],
+    /* */
+    comment: [
+      [/[^\(\*]+/, "comment"],
+      //[/\(\*/,    'comment', '@push' ],    // nested comment  not allowed :-(
+      [/\*\)/, "comment", "@pop"],
+      [/\(\*/, "comment"]
+    ],
+    string: [
+      [/[^\\']+/, "string"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, { token: "string.quote", bracket: "@close", next: "@pop" }]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, "white"],
+      [/\(\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ]
+  }
+};
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=cameligo-NOFINCMB.js.map

web/node_modules/.vite/deps/cameligo-NOFINCMB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../monaco-editor/esm/vs/basic-languages/cameligo/cameligo.js"],
+  "sourcesContent": ["const conf = {\n  comments: {\n    lineComment: \"//\",\n    blockComment: [\"(*\", \"*)\"]\n  },\n  brackets: [\n    [\"{\", \"}\"],\n    [\"[\", \"]\"],\n    [\"(\", \")\"],\n    [\"<\", \">\"]\n  ],\n  autoClosingPairs: [\n    { open: \"{\", close: \"}\" },\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: \"<\", close: \">\" },\n    { open: \"'\", close: \"'\" },\n    { open: '\"', close: '\"' },\n    { open: \"(*\", close: \"*)\" }\n  ],\n  surroundingPairs: [\n    { open: \"{\", close: \"}\" },\n    { open: \"[\", close: \"]\" },\n    { open: \"(\", close: \")\" },\n    { open: \"<\", close: \">\" },\n    { open: \"'\", close: \"'\" },\n    { open: '\"', close: '\"' },\n    { open: \"(*\", close: \"*)\" }\n  ]\n};\nconst language = {\n  defaultToken: \"\",\n  tokenPostfix: \".cameligo\",\n  ignoreCase: true,\n  brackets: [\n    { open: \"{\", close: \"}\", token: \"delimiter.curly\" },\n    { open: \"[\", close: \"]\", token: \"delimiter.square\" },\n    { open: \"(\", close: \")\", token: \"delimiter.parenthesis\" },\n    { open: \"<\", close: \">\", token: \"delimiter.angle\" }\n  ],\n  keywords: [\n    \"abs\",\n    \"assert\",\n    \"block\",\n    \"Bytes\",\n    \"case\",\n    \"Crypto\",\n    \"Current\",\n    \"else\",\n    \"failwith\",\n    \"false\",\n    \"for\",\n    \"fun\",\n    \"if\",\n    \"in\",\n    \"let\",\n    \"let%entry\",\n    \"let%init\",\n    \"List\",\n    \"list\",\n    \"Map\",\n    \"map\",\n    \"match\",\n    \"match%nat\",\n    \"mod\",\n    \"not\",\n    \"operation\",\n    \"Operation\",\n    \"of\",\n    \"record\",\n    \"Set\",\n    \"set\",\n    \"sender\",\n    \"skip\",\n    \"source\",\n    \"String\",\n    \"then\",\n    \"to\",\n    \"true\",\n    \"type\",\n    \"with\"\n  ],\n  typeKeywords: [\"int\", \"unit\", \"string\", \"tz\", \"nat\", \"bool\"],\n  operators: [\n    \"=\",\n    \">\",\n    \"<\",\n    \"<=\",\n    \">=\",\n    \"<>\",\n    \":\",\n    \":=\",\n    \"and\",\n    \"mod\",\n    \"or\",\n    \"+\",\n    \"-\",\n    \"*\",\n    \"/\",\n    \"@\",\n    \"&\",\n    \"^\",\n    \"%\",\n    \"->\",\n    \"<-\",\n    \"&&\",\n    \"||\"\n  ],\n  // we include these common regular expressions\n  symbols: /[=><:@\\^&|+\\-*\\/\\^%]+/,\n  // The main tokenizer for our languages\n  tokenizer: {\n    root: [\n      // identifiers and keywords\n      [\n        /[a-zA-Z_][\\w]*/,\n        {\n          cases: {\n            \"@keywords\": { token: \"keyword.$0\" },\n            \"@default\": \"identifier\"\n          }\n        }\n      ],\n      // whitespace\n      { include: \"@whitespace\" },\n      // delimiters and operators\n      [/[{}()\\[\\]]/, \"@brackets\"],\n      [/[<>](?!@symbols)/, \"@brackets\"],\n      [\n        /@symbols/,\n        {\n          cases: {\n            \"@operators\": \"delimiter\",\n            \"@default\": \"\"\n          }\n        }\n      ],\n      // numbers\n      [/\\d*\\.\\d+([eE][\\-+]?\\d+)?/, \"number.float\"],\n      [/\\$[0-9a-fA-F]{1,16}/, \"number.hex\"],\n      [/\\d+/, \"number\"],\n      // delimiter: after number because of .\\d floats\n      [/[;,.]/, \"delimiter\"],\n      // strings\n      [/'([^'\\\\]|\\\\.)*$/, \"string.invalid\"],\n      // non-teminated string\n      [/'/, \"string\", \"@string\"],\n      // characters\n      [/'[^\\\\']'/, \"string\"],\n      [/'/, \"string.invalid\"],\n      [/\\#\\d+/, \"string\"]\n    ],\n    /* */\n    comment: [\n      [/[^\\(\\*]+/, \"comment\"],\n      //[/\\(\\*/,    'comment', '@push' ],    // nested comment  not allowed :-(\n      [/\\*\\)/, \"comment\", \"@pop\"],\n      [/\\(\\*/, \"comment\"]\n    ],\n    string: [\n      [/[^\\\\']+/, \"string\"],\n      [/\\\\./, \"string.escape.invalid\"],\n      [/'/, { token: \"string.quote\", bracket: \"@close\", next: \"@pop\" }]\n    ],\n    whitespace: [\n      [/[ \\t\\r\\n]+/, \"white\"],\n      [/\\(\\*/, \"comment\", \"@comment\"],\n      [/\\/\\/.*$/, \"comment\"]\n    ]\n  }\n};\n\nexport { conf, language };\n"],
+  "mappings": ";;;AAAA,IAAM,OAAO;AAAA,EACX,UAAU;AAAA,IACR,aAAa;AAAA,IACb,cAAc,CAAC,MAAM,IAAI;AAAA,EAC3B;AAAA,EACA,UAAU;AAAA,IACR,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,IACT,CAAC,KAAK,GAAG;AAAA,EACX;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,MAAM,OAAO,KAAK;AAAA,EAC5B;AAAA,EACA,kBAAkB;AAAA,IAChB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,KAAK,OAAO,IAAI;AAAA,IACxB,EAAE,MAAM,MAAM,OAAO,KAAK;AAAA,EAC5B;AACF;AACA,IAAM,WAAW;AAAA,EACf,cAAc;AAAA,EACd,cAAc;AAAA,EACd,YAAY;AAAA,EACZ,UAAU;AAAA,IACR,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,kBAAkB;AAAA,IAClD,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,mBAAmB;AAAA,IACnD,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,wBAAwB;AAAA,IACxD,EAAE,MAAM,KAAK,OAAO,KAAK,OAAO,kBAAkB;AAAA,EACpD;AAAA,EACA,UAAU;AAAA,IACR;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA,cAAc,CAAC,OAAO,QAAQ,UAAU,MAAM,OAAO,MAAM;AAAA,EAC3D,WAAW;AAAA,IACT;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA;AAAA,EAEA,SAAS;AAAA;AAAA,EAET,WAAW;AAAA,IACT,MAAM;AAAA;AAAA,MAEJ;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,aAAa,EAAE,OAAO,aAAa;AAAA,YACnC,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA;AAAA,MAEA,EAAE,SAAS,cAAc;AAAA;AAAA,MAEzB,CAAC,cAAc,WAAW;AAAA,MAC1B,CAAC,oBAAoB,WAAW;AAAA,MAChC;AAAA,QACE;AAAA,QACA;AAAA,UACE,OAAO;AAAA,YACL,cAAc;AAAA,YACd,YAAY;AAAA,UACd;AAAA,QACF;AAAA,MACF;AAAA;AAAA,MAEA,CAAC,4BAA4B,cAAc;AAAA,MAC3C,CAAC,uBAAuB,YAAY;AAAA,MACpC,CAAC,OAAO,QAAQ;AAAA;AAAA,MAEhB,CAAC,SAAS,WAAW;AAAA;AAAA,MAErB,CAAC,mBAAmB,gBAAgB;AAAA;AAAA,MAEpC,CAAC,KAAK,UAAU,SAAS;AAAA;AAAA,MAEzB,CAAC,YAAY,QAAQ;AAAA,MACrB,CAAC,KAAK,gBAAgB;AAAA,MACtB,CAAC,SAAS,QAAQ;AAAA,IACpB;AAAA;AAAA,IAEA,SAAS;AAAA,MACP,CAAC,YAAY,SAAS;AAAA;AAAA,MAEtB,CAAC,QAAQ,WAAW,MAAM;AAAA,MAC1B,CAAC,QAAQ,SAAS;AAAA,IACpB;AAAA,IACA,QAAQ;AAAA,MACN,CAAC,WAAW,QAAQ;AAAA,MACpB,CAAC,OAAO,uBAAuB;AAAA,MAC/B,CAAC,KAAK,EAAE,OAAO,gBAAgB,SAAS,UAAU,MAAM,OAAO,CAAC;AAAA,IAClE;AAAA,IACA,YAAY;AAAA,MACV,CAAC,cAAc,OAAO;AAAA,MACtB,CAAC,QAAQ,WAAW,UAAU;AAAA,MAC9B,CAAC,WAAW,SAAS;AAAA,IACvB;AAAA,EACF;AACF;",
+  "names": []
+}

web/node_modules/.vite/deps/chunk-2UYAFQ3I.js

@@ -0,0 +1,202 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/react-is/cjs/react-is.development.js
+var require_react_is_development = __commonJS({
+  "node_modules/react-is/cjs/react-is.development.js"(exports) {
+    "use strict";
+    if (true) {
+      (function() {
+        "use strict";
+        var REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("react.element");
+        var REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for("react.portal");
+        var REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for("react.fragment");
+        var REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for("react.strict_mode");
+        var REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for("react.profiler");
+        var REACT_PROVIDER_TYPE = /* @__PURE__ */ Symbol.for("react.provider");
+        var REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.context");
+        var REACT_SERVER_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for("react.server_context");
+        var REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for("react.forward_ref");
+        var REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for("react.suspense");
+        var REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for("react.suspense_list");
+        var REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for("react.memo");
+        var REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for("react.lazy");
+        var REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for("react.offscreen");
+        var enableScopeAPI = false;
+        var enableCacheElement = false;
+        var enableTransitionTracing = false;
+        var enableLegacyHidden = false;
+        var enableDebugTracing = false;
+        var REACT_MODULE_REFERENCE;
+        {
+          REACT_MODULE_REFERENCE = /* @__PURE__ */ Symbol.for("react.module.reference");
+        }
+        function isValidElementType(type) {
+          if (typeof type === "string" || typeof type === "function") {
+            return true;
+          }
+          if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || enableLegacyHidden || type === REACT_OFFSCREEN_TYPE || enableScopeAPI || enableCacheElement || enableTransitionTracing) {
+            return true;
+          }
+          if (typeof type === "object" && type !== null) {
+            if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || // This needs to include all possible module reference object
+            // types supported by any Flight configuration anywhere since
+            // we don't know which Flight build this will end up being used
+            // with.
+            type.$$typeof === REACT_MODULE_REFERENCE || type.getModuleId !== void 0) {
+              return true;
+            }
+          }
+          return false;
+        }
+        function typeOf(object) {
+          if (typeof object === "object" && object !== null) {
+            var $$typeof = object.$$typeof;
+            switch ($$typeof) {
+              case REACT_ELEMENT_TYPE:
+                var type = object.type;
+                switch (type) {
+                  case REACT_FRAGMENT_TYPE:
+                  case REACT_PROFILER_TYPE:
+                  case REACT_STRICT_MODE_TYPE:
+                  case REACT_SUSPENSE_TYPE:
+                  case REACT_SUSPENSE_LIST_TYPE:
+                    return type;
+                  default:
+                    var $$typeofType = type && type.$$typeof;
+                    switch ($$typeofType) {
+                      case REACT_SERVER_CONTEXT_TYPE:
+                      case REACT_CONTEXT_TYPE:
+                      case REACT_FORWARD_REF_TYPE:
+                      case REACT_LAZY_TYPE:
+                      case REACT_MEMO_TYPE:
+                      case REACT_PROVIDER_TYPE:
+                        return $$typeofType;
+                      default:
+                        return $$typeof;
+                    }
+                }
+              case REACT_PORTAL_TYPE:
+                return $$typeof;
+            }
+          }
+          return void 0;
+        }
+        var ContextConsumer = REACT_CONTEXT_TYPE;
+        var ContextProvider = REACT_PROVIDER_TYPE;
+        var Element = REACT_ELEMENT_TYPE;
+        var ForwardRef = REACT_FORWARD_REF_TYPE;
+        var Fragment = REACT_FRAGMENT_TYPE;
+        var Lazy = REACT_LAZY_TYPE;
+        var Memo = REACT_MEMO_TYPE;
+        var Portal = REACT_PORTAL_TYPE;
+        var Profiler = REACT_PROFILER_TYPE;
+        var StrictMode = REACT_STRICT_MODE_TYPE;
+        var Suspense = REACT_SUSPENSE_TYPE;
+        var SuspenseList = REACT_SUSPENSE_LIST_TYPE;
+        var hasWarnedAboutDeprecatedIsAsyncMode = false;
+        var hasWarnedAboutDeprecatedIsConcurrentMode = false;
+        function isAsyncMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+              hasWarnedAboutDeprecatedIsAsyncMode = true;
+              console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isConcurrentMode(object) {
+          {
+            if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+              hasWarnedAboutDeprecatedIsConcurrentMode = true;
+              console["warn"]("The ReactIs.isConcurrentMode() alias has been deprecated, and will be removed in React 18+.");
+            }
+          }
+          return false;
+        }
+        function isContextConsumer(object) {
+          return typeOf(object) === REACT_CONTEXT_TYPE;
+        }
+        function isContextProvider(object) {
+          return typeOf(object) === REACT_PROVIDER_TYPE;
+        }
+        function isElement(object) {
+          return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+        }
+        function isForwardRef(object) {
+          return typeOf(object) === REACT_FORWARD_REF_TYPE;
+        }
+        function isFragment(object) {
+          return typeOf(object) === REACT_FRAGMENT_TYPE;
+        }
+        function isLazy(object) {
+          return typeOf(object) === REACT_LAZY_TYPE;
+        }
+        function isMemo(object) {
+          return typeOf(object) === REACT_MEMO_TYPE;
+        }
+        function isPortal(object) {
+          return typeOf(object) === REACT_PORTAL_TYPE;
+        }
+        function isProfiler(object) {
+          return typeOf(object) === REACT_PROFILER_TYPE;
+        }
+        function isStrictMode(object) {
+          return typeOf(object) === REACT_STRICT_MODE_TYPE;
+        }
+        function isSuspense(object) {
+          return typeOf(object) === REACT_SUSPENSE_TYPE;
+        }
+        function isSuspenseList(object) {
+          return typeOf(object) === REACT_SUSPENSE_LIST_TYPE;
+        }
+        exports.ContextConsumer = ContextConsumer;
+        exports.ContextProvider = ContextProvider;
+        exports.Element = Element;
+        exports.ForwardRef = ForwardRef;
+        exports.Fragment = Fragment;
+        exports.Lazy = Lazy;
+        exports.Memo = Memo;
+        exports.Portal = Portal;
+        exports.Profiler = Profiler;
+        exports.StrictMode = StrictMode;
+        exports.Suspense = Suspense;
+        exports.SuspenseList = SuspenseList;
+        exports.isAsyncMode = isAsyncMode;
+        exports.isConcurrentMode = isConcurrentMode;
+        exports.isContextConsumer = isContextConsumer;
+        exports.isContextProvider = isContextProvider;
+        exports.isElement = isElement;
+        exports.isForwardRef = isForwardRef;
+        exports.isFragment = isFragment;
+        exports.isLazy = isLazy;
+        exports.isMemo = isMemo;
+        exports.isPortal = isPortal;
+        exports.isProfiler = isProfiler;
+        exports.isStrictMode = isStrictMode;
+        exports.isSuspense = isSuspense;
+        exports.isSuspenseList = isSuspenseList;
+        exports.isValidElementType = isValidElementType;
+        exports.typeOf = typeOf;
+      })();
+    }
+  }
+});
+
+// node_modules/react-is/index.js
+var require_react_is = __commonJS({
+  "node_modules/react-is/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_react_is_development();
+    }
+  }
+});
+
+export {
+  require_react_is
+};
+//# sourceMappingURL=chunk-2UYAFQ3I.js.map

web/node_modules/.vite/deps/chunk-3DUEC4BE.js

@@ -0,0 +1,311 @@
+import {
+  require_react
+} from "./chunk-7ZNOTH45.js";
+import {
+  __toESM
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@dnd-kit/utilities/dist/utilities.esm.js
+var import_react = __toESM(require_react());
+function useCombinedRefs() {
+  for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
+    refs[_key] = arguments[_key];
+  }
+  return (0, import_react.useMemo)(
+    () => (node) => {
+      refs.forEach((ref) => ref(node));
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    refs
+  );
+}
+var canUseDOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+function isWindow(element) {
+  const elementString = Object.prototype.toString.call(element);
+  return elementString === "[object Window]" || // In Electron context the Window object serializes to [object global]
+  elementString === "[object global]";
+}
+function isNode(node) {
+  return "nodeType" in node;
+}
+function getWindow(target) {
+  var _target$ownerDocument, _target$ownerDocument2;
+  if (!target) {
+    return window;
+  }
+  if (isWindow(target)) {
+    return target;
+  }
+  if (!isNode(target)) {
+    return window;
+  }
+  return (_target$ownerDocument = (_target$ownerDocument2 = target.ownerDocument) == null ? void 0 : _target$ownerDocument2.defaultView) != null ? _target$ownerDocument : window;
+}
+function isDocument(node) {
+  const {
+    Document
+  } = getWindow(node);
+  return node instanceof Document;
+}
+function isHTMLElement(node) {
+  if (isWindow(node)) {
+    return false;
+  }
+  return node instanceof getWindow(node).HTMLElement;
+}
+function isSVGElement(node) {
+  return node instanceof getWindow(node).SVGElement;
+}
+function getOwnerDocument(target) {
+  if (!target) {
+    return document;
+  }
+  if (isWindow(target)) {
+    return target.document;
+  }
+  if (!isNode(target)) {
+    return document;
+  }
+  if (isDocument(target)) {
+    return target;
+  }
+  if (isHTMLElement(target) || isSVGElement(target)) {
+    return target.ownerDocument;
+  }
+  return document;
+}
+var useIsomorphicLayoutEffect = canUseDOM ? import_react.useLayoutEffect : import_react.useEffect;
+function useEvent(handler) {
+  const handlerRef = (0, import_react.useRef)(handler);
+  useIsomorphicLayoutEffect(() => {
+    handlerRef.current = handler;
+  });
+  return (0, import_react.useCallback)(function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return handlerRef.current == null ? void 0 : handlerRef.current(...args);
+  }, []);
+}
+function useInterval() {
+  const intervalRef = (0, import_react.useRef)(null);
+  const set = (0, import_react.useCallback)((listener, duration) => {
+    intervalRef.current = setInterval(listener, duration);
+  }, []);
+  const clear = (0, import_react.useCallback)(() => {
+    if (intervalRef.current !== null) {
+      clearInterval(intervalRef.current);
+      intervalRef.current = null;
+    }
+  }, []);
+  return [set, clear];
+}
+function useLatestValue(value, dependencies) {
+  if (dependencies === void 0) {
+    dependencies = [value];
+  }
+  const valueRef = (0, import_react.useRef)(value);
+  useIsomorphicLayoutEffect(() => {
+    if (valueRef.current !== value) {
+      valueRef.current = value;
+    }
+  }, dependencies);
+  return valueRef;
+}
+function useLazyMemo(callback, dependencies) {
+  const valueRef = (0, import_react.useRef)();
+  return (0, import_react.useMemo)(
+    () => {
+      const newValue = callback(valueRef.current);
+      valueRef.current = newValue;
+      return newValue;
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [...dependencies]
+  );
+}
+function useNodeRef(onChange) {
+  const onChangeHandler = useEvent(onChange);
+  const node = (0, import_react.useRef)(null);
+  const setNodeRef = (0, import_react.useCallback)(
+    (element) => {
+      if (element !== node.current) {
+        onChangeHandler == null ? void 0 : onChangeHandler(element, node.current);
+      }
+      node.current = element;
+    },
+    //eslint-disable-next-line
+    []
+  );
+  return [node, setNodeRef];
+}
+function usePrevious(value) {
+  const ref = (0, import_react.useRef)();
+  (0, import_react.useEffect)(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+var ids = {};
+function useUniqueId(prefix, value) {
+  return (0, import_react.useMemo)(() => {
+    if (value) {
+      return value;
+    }
+    const id = ids[prefix] == null ? 0 : ids[prefix] + 1;
+    ids[prefix] = id;
+    return prefix + "-" + id;
+  }, [prefix, value]);
+}
+function createAdjustmentFn(modifier) {
+  return function(object) {
+    for (var _len = arguments.length, adjustments = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      adjustments[_key - 1] = arguments[_key];
+    }
+    return adjustments.reduce((accumulator, adjustment) => {
+      const entries = Object.entries(adjustment);
+      for (const [key, valueAdjustment] of entries) {
+        const value = accumulator[key];
+        if (value != null) {
+          accumulator[key] = value + modifier * valueAdjustment;
+        }
+      }
+      return accumulator;
+    }, {
+      ...object
+    });
+  };
+}
+var add = createAdjustmentFn(1);
+var subtract = createAdjustmentFn(-1);
+function hasViewportRelativeCoordinates(event) {
+  return "clientX" in event && "clientY" in event;
+}
+function isKeyboardEvent(event) {
+  if (!event) {
+    return false;
+  }
+  const {
+    KeyboardEvent
+  } = getWindow(event.target);
+  return KeyboardEvent && event instanceof KeyboardEvent;
+}
+function isTouchEvent(event) {
+  if (!event) {
+    return false;
+  }
+  const {
+    TouchEvent
+  } = getWindow(event.target);
+  return TouchEvent && event instanceof TouchEvent;
+}
+function getEventCoordinates(event) {
+  if (isTouchEvent(event)) {
+    if (event.touches && event.touches.length) {
+      const {
+        clientX: x,
+        clientY: y
+      } = event.touches[0];
+      return {
+        x,
+        y
+      };
+    } else if (event.changedTouches && event.changedTouches.length) {
+      const {
+        clientX: x,
+        clientY: y
+      } = event.changedTouches[0];
+      return {
+        x,
+        y
+      };
+    }
+  }
+  if (hasViewportRelativeCoordinates(event)) {
+    return {
+      x: event.clientX,
+      y: event.clientY
+    };
+  }
+  return null;
+}
+var CSS = Object.freeze({
+  Translate: {
+    toString(transform) {
+      if (!transform) {
+        return;
+      }
+      const {
+        x,
+        y
+      } = transform;
+      return "translate3d(" + (x ? Math.round(x) : 0) + "px, " + (y ? Math.round(y) : 0) + "px, 0)";
+    }
+  },
+  Scale: {
+    toString(transform) {
+      if (!transform) {
+        return;
+      }
+      const {
+        scaleX,
+        scaleY
+      } = transform;
+      return "scaleX(" + scaleX + ") scaleY(" + scaleY + ")";
+    }
+  },
+  Transform: {
+    toString(transform) {
+      if (!transform) {
+        return;
+      }
+      return [CSS.Translate.toString(transform), CSS.Scale.toString(transform)].join(" ");
+    }
+  },
+  Transition: {
+    toString(_ref) {
+      let {
+        property,
+        duration,
+        easing
+      } = _ref;
+      return property + " " + duration + "ms " + easing;
+    }
+  }
+});
+var SELECTOR = "a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not(:disabled),*[tabindex]";
+function findFirstFocusableNode(element) {
+  if (element.matches(SELECTOR)) {
+    return element;
+  }
+  return element.querySelector(SELECTOR);
+}
+
+export {
+  useCombinedRefs,
+  canUseDOM,
+  isWindow,
+  isNode,
+  getWindow,
+  isDocument,
+  isHTMLElement,
+  isSVGElement,
+  getOwnerDocument,
+  useIsomorphicLayoutEffect,
+  useEvent,
+  useInterval,
+  useLatestValue,
+  useLazyMemo,
+  useNodeRef,
+  usePrevious,
+  useUniqueId,
+  add,
+  subtract,
+  hasViewportRelativeCoordinates,
+  isKeyboardEvent,
+  isTouchEvent,
+  getEventCoordinates,
+  CSS,
+  findFirstFocusableNode
+};
+//# sourceMappingURL=chunk-3DUEC4BE.js.map

web/node_modules/.vite/deps/chunk-4NTHFIFD.js

@@ -0,0 +1,27 @@
+// node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function(n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+// node_modules/@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+
+export {
+  _extends,
+  _objectWithoutPropertiesLoose
+};
+//# sourceMappingURL=chunk-4NTHFIFD.js.map

web/node_modules/.vite/deps/chunk-4NTHFIFD.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../@babel/runtime/helpers/esm/extends.js", "../../@babel/runtime/helpers/esm/objectWithoutPropertiesLoose.js"],
+  "sourcesContent": ["function _extends() {\n  return _extends = Object.assign ? Object.assign.bind() : function (n) {\n    for (var e = 1; e < arguments.length; e++) {\n      var t = arguments[e];\n      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);\n    }\n    return n;\n  }, _extends.apply(null, arguments);\n}\nexport { _extends as default };", "function _objectWithoutPropertiesLoose(r, e) {\n  if (null == r) return {};\n  var t = {};\n  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {\n    if (-1 !== e.indexOf(n)) continue;\n    t[n] = r[n];\n  }\n  return t;\n}\nexport { _objectWithoutPropertiesLoose as default };"],
+  "mappings": ";AAAA,SAAS,WAAW;AAClB,SAAO,WAAW,OAAO,SAAS,OAAO,OAAO,KAAK,IAAI,SAAU,GAAG;AACpE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,UAAI,IAAI,UAAU,CAAC;AACnB,eAAS,KAAK,EAAG,EAAC,CAAC,GAAG,eAAe,KAAK,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC;AAAA,IAChE;AACA,WAAO;AAAA,EACT,GAAG,SAAS,MAAM,MAAM,SAAS;AACnC;;;ACRA,SAAS,8BAA8B,GAAG,GAAG;AAC3C,MAAI,QAAQ,EAAG,QAAO,CAAC;AACvB,MAAI,IAAI,CAAC;AACT,WAAS,KAAK,EAAG,KAAI,CAAC,EAAE,eAAe,KAAK,GAAG,CAAC,GAAG;AACjD,QAAI,OAAO,EAAE,QAAQ,CAAC,EAAG;AACzB,MAAE,CAAC,IAAI,EAAE,CAAC;AAAA,EACZ;AACA,SAAO;AACT;",
+  "names": []
+}

web/node_modules/.vite/deps/chunk-5SEBTWNG.js

@@ -0,0 +1,345 @@
+import {
+  languages
+} from "./chunk-GUNMJBQ5.js";
+
+// node_modules/monaco-editor/esm/vs/basic-languages/typescript/typescript.js
+import "E:/Code/terminal/next-terminal-1.3.9/web/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
+import "E:/Code/terminal/next-terminal-1.3.9/web/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css";
+var conf = {
+  wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
+  comments: {
+    lineComment: "//",
+    blockComment: ["/*", "*/"]
+  },
+  brackets: [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  onEnterRules: [
+    {
+      // e.g. /** | */
+      beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+      afterText: /^\s*\*\/$/,
+      action: {
+        indentAction: languages.IndentAction.IndentOutdent,
+        appendText: " * "
+      }
+    },
+    {
+      // e.g. /** ...|
+      beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
+      action: {
+        indentAction: languages.IndentAction.None,
+        appendText: " * "
+      }
+    },
+    {
+      // e.g.  * ...|
+      beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
+      action: {
+        indentAction: languages.IndentAction.None,
+        appendText: "* "
+      }
+    },
+    {
+      // e.g.  */|
+      beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
+      action: {
+        indentAction: languages.IndentAction.None,
+        removeText: 1
+      }
+    }
+  ],
+  autoClosingPairs: [
+    { open: "{", close: "}" },
+    { open: "[", close: "]" },
+    { open: "(", close: ")" },
+    { open: '"', close: '"', notIn: ["string"] },
+    { open: "'", close: "'", notIn: ["string", "comment"] },
+    { open: "`", close: "`", notIn: ["string", "comment"] },
+    { open: "/**", close: " */", notIn: ["string"] }
+  ],
+  folding: {
+    markers: {
+      start: new RegExp("^\\s*//\\s*#?region\\b"),
+      end: new RegExp("^\\s*//\\s*#?endregion\\b")
+    }
+  }
+};
+var language = {
+  // Set defaultToken to invalid to see what you do not tokenize yet
+  defaultToken: "invalid",
+  tokenPostfix: ".ts",
+  keywords: [
+    // Should match the keys of textToKeywordObj in
+    // https://github.com/microsoft/TypeScript/blob/master/src/compiler/scanner.ts
+    "abstract",
+    "any",
+    "as",
+    "asserts",
+    "bigint",
+    "boolean",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "continue",
+    "const",
+    "constructor",
+    "debugger",
+    "declare",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "infer",
+    "instanceof",
+    "interface",
+    "is",
+    "keyof",
+    "let",
+    "module",
+    "namespace",
+    "never",
+    "new",
+    "null",
+    "number",
+    "object",
+    "out",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "override",
+    "readonly",
+    "require",
+    "global",
+    "return",
+    "satisfies",
+    "set",
+    "static",
+    "string",
+    "super",
+    "switch",
+    "symbol",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "undefined",
+    "unique",
+    "unknown",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "async",
+    "await",
+    "of"
+  ],
+  operators: [
+    "<=",
+    ">=",
+    "==",
+    "!=",
+    "===",
+    "!==",
+    "=>",
+    "+",
+    "-",
+    "**",
+    "*",
+    "/",
+    "%",
+    "++",
+    "--",
+    "<<",
+    "</",
+    ">>",
+    ">>>",
+    "&",
+    "|",
+    "^",
+    "!",
+    "~",
+    "&&",
+    "||",
+    "??",
+    "?",
+    ":",
+    "=",
+    "+=",
+    "-=",
+    "*=",
+    "**=",
+    "/=",
+    "%=",
+    "<<=",
+    ">>=",
+    ">>>=",
+    "&=",
+    "|=",
+    "^=",
+    "@"
+  ],
+  // we include these common regular expressions
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+  escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+  digits: /\d+(_+\d+)*/,
+  octaldigits: /[0-7]+(_+[0-7]+)*/,
+  binarydigits: /[0-1]+(_+[0-1]+)*/,
+  hexdigits: /[[0-9a-fA-F]+(_+[0-9a-fA-F]+)*/,
+  regexpctl: /[(){}\[\]\$\^|\-*+?\.]/,
+  regexpesc: /\\(?:[bBdDfnrstvwWn0\\\/]|@regexpctl|c[A-Z]|x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4})/,
+  // The main tokenizer for our languages
+  tokenizer: {
+    root: [[/[{}]/, "delimiter.bracket"], { include: "common" }],
+    common: [
+      // identifiers and keywords
+      [
+        /#?[a-z_$][\w$]*/,
+        {
+          cases: {
+            "@keywords": "keyword",
+            "@default": "identifier"
+          }
+        }
+      ],
+      [/[A-Z][\w\$]*/, "type.identifier"],
+      // to show class names nicely
+      // [/[A-Z][\w\$]*/, 'identifier'],
+      // whitespace
+      { include: "@whitespace" },
+      // regular expression: ensure it is terminated before beginning (otherwise it is an opeator)
+      [
+        /\/(?=([^\\\/]|\\.)+\/([dgimsuy]*)(\s*)(\.|;|,|\)|\]|\}|$))/,
+        { token: "regexp", bracket: "@open", next: "@regexp" }
+      ],
+      // delimiters and operators
+      [/[()\[\]]/, "@brackets"],
+      [/[<>](?!@symbols)/, "@brackets"],
+      [/!(?=([^=]|$))/, "delimiter"],
+      [
+        /@symbols/,
+        {
+          cases: {
+            "@operators": "delimiter",
+            "@default": ""
+          }
+        }
+      ],
+      // numbers
+      [/(@digits)[eE]([\-+]?(@digits))?/, "number.float"],
+      [/(@digits)\.(@digits)([eE][\-+]?(@digits))?/, "number.float"],
+      [/0[xX](@hexdigits)n?/, "number.hex"],
+      [/0[oO]?(@octaldigits)n?/, "number.octal"],
+      [/0[bB](@binarydigits)n?/, "number.binary"],
+      [/(@digits)n?/, "number"],
+      // delimiter: after number because of .\d floats
+      [/[;,.]/, "delimiter"],
+      // strings
+      [/"([^"\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/'([^'\\]|\\.)*$/, "string.invalid"],
+      // non-teminated string
+      [/"/, "string", "@string_double"],
+      [/'/, "string", "@string_single"],
+      [/`/, "string", "@string_backtick"]
+    ],
+    whitespace: [
+      [/[ \t\r\n]+/, ""],
+      [/\/\*\*(?!\/)/, "comment.doc", "@jsdoc"],
+      [/\/\*/, "comment", "@comment"],
+      [/\/\/.*$/, "comment"]
+    ],
+    comment: [
+      [/[^\/*]+/, "comment"],
+      [/\*\//, "comment", "@pop"],
+      [/[\/*]/, "comment"]
+    ],
+    jsdoc: [
+      [/[^\/*]+/, "comment.doc"],
+      [/\*\//, "comment.doc", "@pop"],
+      [/[\/*]/, "comment.doc"]
+    ],
+    // We match regular expression quite precisely
+    regexp: [
+      [
+        /(\{)(\d+(?:,\d*)?)(\})/,
+        ["regexp.escape.control", "regexp.escape.control", "regexp.escape.control"]
+      ],
+      [
+        /(\[)(\^?)(?=(?:[^\]\\\/]|\\.)+)/,
+        ["regexp.escape.control", { token: "regexp.escape.control", next: "@regexrange" }]
+      ],
+      [/(\()(\?:|\?=|\?!)/, ["regexp.escape.control", "regexp.escape.control"]],
+      [/[()]/, "regexp.escape.control"],
+      [/@regexpctl/, "regexp.escape.control"],
+      [/[^\\\/]/, "regexp"],
+      [/@regexpesc/, "regexp.escape"],
+      [/\\\./, "regexp.invalid"],
+      [/(\/)([dgimsuy]*)/, [{ token: "regexp", bracket: "@close", next: "@pop" }, "keyword.other"]]
+    ],
+    regexrange: [
+      [/-/, "regexp.escape.control"],
+      [/\^/, "regexp.invalid"],
+      [/@regexpesc/, "regexp.escape"],
+      [/[^\]]/, "regexp"],
+      [
+        /\]/,
+        {
+          token: "regexp.escape.control",
+          next: "@pop",
+          bracket: "@close"
+        }
+      ]
+    ],
+    string_double: [
+      [/[^\\"]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/"/, "string", "@pop"]
+    ],
+    string_single: [
+      [/[^\\']+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/'/, "string", "@pop"]
+    ],
+    string_backtick: [
+      [/\$\{/, { token: "delimiter.bracket", next: "@bracketCounting" }],
+      [/[^\\`$]+/, "string"],
+      [/@escapes/, "string.escape"],
+      [/\\./, "string.escape.invalid"],
+      [/`/, "string", "@pop"]
+    ],
+    bracketCounting: [
+      [/\{/, "delimiter.bracket", "@bracketCounting"],
+      [/\}/, "delimiter.bracket", "@pop"],
+      { include: "common" }
+    ]
+  }
+};
+
+export {
+  conf,
+  language
+};
+//# sourceMappingURL=chunk-5SEBTWNG.js.map

web/node_modules/.vite/deps/chunk-5T3YOWZX.js

@@ -0,0 +1,811 @@
+import {
+  _defineProperty,
+  init_defineProperty
+} from "./chunk-R546NDVX.js";
+import {
+  __esm,
+  __export
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@ant-design/fast-color/es/FastColor.js
+function splitColorStr(str, parseNum) {
+  const match = str.replace(/^[^(]*\((.*)/, "$1").replace(/\).*/, "").match(/\d*\.?\d+%?/g) || [];
+  const numList = match.map((item) => parseFloat(item));
+  for (let i = 0; i < 3; i += 1) {
+    numList[i] = parseNum(numList[i] || 0, match[i] || "", i);
+  }
+  if (match[3]) {
+    numList[3] = match[3].includes("%") ? numList[3] / 100 : numList[3];
+  } else {
+    numList[3] = 1;
+  }
+  return numList;
+}
+function limitRange(value, max) {
+  const mergedMax = max || 255;
+  if (value > mergedMax) {
+    return mergedMax;
+  }
+  if (value < 0) {
+    return 0;
+  }
+  return value;
+}
+var round, parseHSVorHSL, FastColor;
+var init_FastColor = __esm({
+  "node_modules/@ant-design/fast-color/es/FastColor.js"() {
+    init_defineProperty();
+    round = Math.round;
+    parseHSVorHSL = (num, _, index) => index === 0 ? num : num / 100;
+    FastColor = class _FastColor {
+      constructor(input) {
+        _defineProperty(this, "isValid", true);
+        _defineProperty(this, "r", 0);
+        _defineProperty(this, "g", 0);
+        _defineProperty(this, "b", 0);
+        _defineProperty(this, "a", 1);
+        _defineProperty(this, "_h", void 0);
+        _defineProperty(this, "_s", void 0);
+        _defineProperty(this, "_l", void 0);
+        _defineProperty(this, "_v", void 0);
+        _defineProperty(this, "_max", void 0);
+        _defineProperty(this, "_min", void 0);
+        _defineProperty(this, "_brightness", void 0);
+        function matchFormat(str) {
+          return str[0] in input && str[1] in input && str[2] in input;
+        }
+        if (!input) {
+        } else if (typeof input === "string") {
+          let matchPrefix = function(prefix) {
+            return trimStr.startsWith(prefix);
+          };
+          const trimStr = input.trim();
+          if (/^#?[A-F\d]{3,8}$/i.test(trimStr)) {
+            this.fromHexString(trimStr);
+          } else if (matchPrefix("rgb")) {
+            this.fromRgbString(trimStr);
+          } else if (matchPrefix("hsl")) {
+            this.fromHslString(trimStr);
+          } else if (matchPrefix("hsv") || matchPrefix("hsb")) {
+            this.fromHsvString(trimStr);
+          }
+        } else if (input instanceof _FastColor) {
+          this.r = input.r;
+          this.g = input.g;
+          this.b = input.b;
+          this.a = input.a;
+          this._h = input._h;
+          this._s = input._s;
+          this._l = input._l;
+          this._v = input._v;
+        } else if (matchFormat("rgb")) {
+          this.r = limitRange(input.r);
+          this.g = limitRange(input.g);
+          this.b = limitRange(input.b);
+          this.a = typeof input.a === "number" ? limitRange(input.a, 1) : 1;
+        } else if (matchFormat("hsl")) {
+          this.fromHsl(input);
+        } else if (matchFormat("hsv")) {
+          this.fromHsv(input);
+        } else {
+          throw new Error("@ant-design/fast-color: unsupported input " + JSON.stringify(input));
+        }
+      }
+      // ======================= Setter =======================
+      setR(value) {
+        return this._sc("r", value);
+      }
+      setG(value) {
+        return this._sc("g", value);
+      }
+      setB(value) {
+        return this._sc("b", value);
+      }
+      setA(value) {
+        return this._sc("a", value, 1);
+      }
+      setHue(value) {
+        const hsv = this.toHsv();
+        hsv.h = value;
+        return this._c(hsv);
+      }
+      // ======================= Getter =======================
+      /**
+       * Returns the perceived luminance of a color, from 0-1.
+       * @see http://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
+       */
+      getLuminance() {
+        function adjustGamma(raw) {
+          const val = raw / 255;
+          return val <= 0.03928 ? val / 12.92 : Math.pow((val + 0.055) / 1.055, 2.4);
+        }
+        const R = adjustGamma(this.r);
+        const G = adjustGamma(this.g);
+        const B = adjustGamma(this.b);
+        return 0.2126 * R + 0.7152 * G + 0.0722 * B;
+      }
+      getHue() {
+        if (typeof this._h === "undefined") {
+          const delta = this.getMax() - this.getMin();
+          if (delta === 0) {
+            this._h = 0;
+          } else {
+            this._h = round(60 * (this.r === this.getMax() ? (this.g - this.b) / delta + (this.g < this.b ? 6 : 0) : this.g === this.getMax() ? (this.b - this.r) / delta + 2 : (this.r - this.g) / delta + 4));
+          }
+        }
+        return this._h;
+      }
+      getSaturation() {
+        if (typeof this._s === "undefined") {
+          const delta = this.getMax() - this.getMin();
+          if (delta === 0) {
+            this._s = 0;
+          } else {
+            this._s = delta / this.getMax();
+          }
+        }
+        return this._s;
+      }
+      getLightness() {
+        if (typeof this._l === "undefined") {
+          this._l = (this.getMax() + this.getMin()) / 510;
+        }
+        return this._l;
+      }
+      getValue() {
+        if (typeof this._v === "undefined") {
+          this._v = this.getMax() / 255;
+        }
+        return this._v;
+      }
+      /**
+       * Returns the perceived brightness of the color, from 0-255.
+       * Note: this is not the b of HSB
+       * @see http://www.w3.org/TR/AERT#color-contrast
+       */
+      getBrightness() {
+        if (typeof this._brightness === "undefined") {
+          this._brightness = (this.r * 299 + this.g * 587 + this.b * 114) / 1e3;
+        }
+        return this._brightness;
+      }
+      // ======================== Func ========================
+      darken(amount = 10) {
+        const h = this.getHue();
+        const s = this.getSaturation();
+        let l = this.getLightness() - amount / 100;
+        if (l < 0) {
+          l = 0;
+        }
+        return this._c({
+          h,
+          s,
+          l,
+          a: this.a
+        });
+      }
+      lighten(amount = 10) {
+        const h = this.getHue();
+        const s = this.getSaturation();
+        let l = this.getLightness() + amount / 100;
+        if (l > 1) {
+          l = 1;
+        }
+        return this._c({
+          h,
+          s,
+          l,
+          a: this.a
+        });
+      }
+      /**
+       * Mix the current color a given amount with another color, from 0 to 100.
+       * 0 means no mixing (return current color).
+       */
+      mix(input, amount = 50) {
+        const color = this._c(input);
+        const p = amount / 100;
+        const calc = (key) => (color[key] - this[key]) * p + this[key];
+        const rgba = {
+          r: round(calc("r")),
+          g: round(calc("g")),
+          b: round(calc("b")),
+          a: round(calc("a") * 100) / 100
+        };
+        return this._c(rgba);
+      }
+      /**
+       * Mix the color with pure white, from 0 to 100.
+       * Providing 0 will do nothing, providing 100 will always return white.
+       */
+      tint(amount = 10) {
+        return this.mix({
+          r: 255,
+          g: 255,
+          b: 255,
+          a: 1
+        }, amount);
+      }
+      /**
+       * Mix the color with pure black, from 0 to 100.
+       * Providing 0 will do nothing, providing 100 will always return black.
+       */
+      shade(amount = 10) {
+        return this.mix({
+          r: 0,
+          g: 0,
+          b: 0,
+          a: 1
+        }, amount);
+      }
+      onBackground(background) {
+        const bg = this._c(background);
+        const alpha = this.a + bg.a * (1 - this.a);
+        const calc = (key) => {
+          return round((this[key] * this.a + bg[key] * bg.a * (1 - this.a)) / alpha);
+        };
+        return this._c({
+          r: calc("r"),
+          g: calc("g"),
+          b: calc("b"),
+          a: alpha
+        });
+      }
+      // ======================= Status =======================
+      isDark() {
+        return this.getBrightness() < 128;
+      }
+      isLight() {
+        return this.getBrightness() >= 128;
+      }
+      // ======================== MISC ========================
+      equals(other) {
+        return this.r === other.r && this.g === other.g && this.b === other.b && this.a === other.a;
+      }
+      clone() {
+        return this._c(this);
+      }
+      // ======================= Format =======================
+      toHexString() {
+        let hex = "#";
+        const rHex = (this.r || 0).toString(16);
+        hex += rHex.length === 2 ? rHex : "0" + rHex;
+        const gHex = (this.g || 0).toString(16);
+        hex += gHex.length === 2 ? gHex : "0" + gHex;
+        const bHex = (this.b || 0).toString(16);
+        hex += bHex.length === 2 ? bHex : "0" + bHex;
+        if (typeof this.a === "number" && this.a >= 0 && this.a < 1) {
+          const aHex = round(this.a * 255).toString(16);
+          hex += aHex.length === 2 ? aHex : "0" + aHex;
+        }
+        return hex;
+      }
+      /** CSS support color pattern */
+      toHsl() {
+        return {
+          h: this.getHue(),
+          s: this.getSaturation(),
+          l: this.getLightness(),
+          a: this.a
+        };
+      }
+      /** CSS support color pattern */
+      toHslString() {
+        const h = this.getHue();
+        const s = round(this.getSaturation() * 100);
+        const l = round(this.getLightness() * 100);
+        return this.a !== 1 ? `hsla(${h},${s}%,${l}%,${this.a})` : `hsl(${h},${s}%,${l}%)`;
+      }
+      /** Same as toHsb */
+      toHsv() {
+        return {
+          h: this.getHue(),
+          s: this.getSaturation(),
+          v: this.getValue(),
+          a: this.a
+        };
+      }
+      toRgb() {
+        return {
+          r: this.r,
+          g: this.g,
+          b: this.b,
+          a: this.a
+        };
+      }
+      toRgbString() {
+        return this.a !== 1 ? `rgba(${this.r},${this.g},${this.b},${this.a})` : `rgb(${this.r},${this.g},${this.b})`;
+      }
+      toString() {
+        return this.toRgbString();
+      }
+      // ====================== Privates ======================
+      /** Return a new FastColor object with one channel changed */
+      _sc(rgb, value, max) {
+        const clone = this.clone();
+        clone[rgb] = limitRange(value, max);
+        return clone;
+      }
+      _c(input) {
+        return new this.constructor(input);
+      }
+      getMax() {
+        if (typeof this._max === "undefined") {
+          this._max = Math.max(this.r, this.g, this.b);
+        }
+        return this._max;
+      }
+      getMin() {
+        if (typeof this._min === "undefined") {
+          this._min = Math.min(this.r, this.g, this.b);
+        }
+        return this._min;
+      }
+      fromHexString(trimStr) {
+        const withoutPrefix = trimStr.replace("#", "");
+        function connectNum(index1, index2) {
+          return parseInt(withoutPrefix[index1] + withoutPrefix[index2 || index1], 16);
+        }
+        if (withoutPrefix.length < 6) {
+          this.r = connectNum(0);
+          this.g = connectNum(1);
+          this.b = connectNum(2);
+          this.a = withoutPrefix[3] ? connectNum(3) / 255 : 1;
+        } else {
+          this.r = connectNum(0, 1);
+          this.g = connectNum(2, 3);
+          this.b = connectNum(4, 5);
+          this.a = withoutPrefix[6] ? connectNum(6, 7) / 255 : 1;
+        }
+      }
+      fromHsl({
+        h,
+        s,
+        l,
+        a
+      }) {
+        this._h = h % 360;
+        this._s = s;
+        this._l = l;
+        this.a = typeof a === "number" ? a : 1;
+        if (s <= 0) {
+          const rgb = round(l * 255);
+          this.r = rgb;
+          this.g = rgb;
+          this.b = rgb;
+        }
+        let r = 0, g = 0, b = 0;
+        const huePrime = h / 60;
+        const chroma = (1 - Math.abs(2 * l - 1)) * s;
+        const secondComponent = chroma * (1 - Math.abs(huePrime % 2 - 1));
+        if (huePrime >= 0 && huePrime < 1) {
+          r = chroma;
+          g = secondComponent;
+        } else if (huePrime >= 1 && huePrime < 2) {
+          r = secondComponent;
+          g = chroma;
+        } else if (huePrime >= 2 && huePrime < 3) {
+          g = chroma;
+          b = secondComponent;
+        } else if (huePrime >= 3 && huePrime < 4) {
+          g = secondComponent;
+          b = chroma;
+        } else if (huePrime >= 4 && huePrime < 5) {
+          r = secondComponent;
+          b = chroma;
+        } else if (huePrime >= 5 && huePrime < 6) {
+          r = chroma;
+          b = secondComponent;
+        }
+        const lightnessModification = l - chroma / 2;
+        this.r = round((r + lightnessModification) * 255);
+        this.g = round((g + lightnessModification) * 255);
+        this.b = round((b + lightnessModification) * 255);
+      }
+      fromHsv({
+        h,
+        s,
+        v,
+        a
+      }) {
+        this._h = h % 360;
+        this._s = s;
+        this._v = v;
+        this.a = typeof a === "number" ? a : 1;
+        const vv = round(v * 255);
+        this.r = vv;
+        this.g = vv;
+        this.b = vv;
+        if (s <= 0) {
+          return;
+        }
+        const hh = h / 60;
+        const i = Math.floor(hh);
+        const ff = hh - i;
+        const p = round(v * (1 - s) * 255);
+        const q = round(v * (1 - s * ff) * 255);
+        const t = round(v * (1 - s * (1 - ff)) * 255);
+        switch (i) {
+          case 0:
+            this.g = t;
+            this.b = p;
+            break;
+          case 1:
+            this.r = q;
+            this.b = p;
+            break;
+          case 2:
+            this.r = p;
+            this.b = t;
+            break;
+          case 3:
+            this.r = p;
+            this.g = q;
+            break;
+          case 4:
+            this.r = t;
+            this.g = p;
+            break;
+          case 5:
+          default:
+            this.g = p;
+            this.b = q;
+            break;
+        }
+      }
+      fromHsvString(trimStr) {
+        const cells = splitColorStr(trimStr, parseHSVorHSL);
+        this.fromHsv({
+          h: cells[0],
+          s: cells[1],
+          v: cells[2],
+          a: cells[3]
+        });
+      }
+      fromHslString(trimStr) {
+        const cells = splitColorStr(trimStr, parseHSVorHSL);
+        this.fromHsl({
+          h: cells[0],
+          s: cells[1],
+          l: cells[2],
+          a: cells[3]
+        });
+      }
+      fromRgbString(trimStr) {
+        const cells = splitColorStr(trimStr, (num, txt) => (
+          // Convert percentage to number. e.g. 50% -> 128
+          txt.includes("%") ? round(num / 100 * 255) : num
+        ));
+        this.r = cells[0];
+        this.g = cells[1];
+        this.b = cells[2];
+        this.a = cells[3];
+      }
+    };
+  }
+});
+
+// node_modules/@ant-design/fast-color/es/types.js
+var init_types = __esm({
+  "node_modules/@ant-design/fast-color/es/types.js"() {
+  }
+});
+
+// node_modules/@ant-design/fast-color/es/index.js
+var init_es = __esm({
+  "node_modules/@ant-design/fast-color/es/index.js"() {
+    init_FastColor();
+    init_types();
+  }
+});
+
+// node_modules/@ant-design/colors/es/generate.js
+function getHue(hsv, i, light) {
+  var hue;
+  if (Math.round(hsv.h) >= 60 && Math.round(hsv.h) <= 240) {
+    hue = light ? Math.round(hsv.h) - hueStep * i : Math.round(hsv.h) + hueStep * i;
+  } else {
+    hue = light ? Math.round(hsv.h) + hueStep * i : Math.round(hsv.h) - hueStep * i;
+  }
+  if (hue < 0) {
+    hue += 360;
+  } else if (hue >= 360) {
+    hue -= 360;
+  }
+  return hue;
+}
+function getSaturation(hsv, i, light) {
+  if (hsv.h === 0 && hsv.s === 0) {
+    return hsv.s;
+  }
+  var saturation;
+  if (light) {
+    saturation = hsv.s - saturationStep * i;
+  } else if (i === darkColorCount) {
+    saturation = hsv.s + saturationStep;
+  } else {
+    saturation = hsv.s + saturationStep2 * i;
+  }
+  if (saturation > 1) {
+    saturation = 1;
+  }
+  if (light && i === lightColorCount && saturation > 0.1) {
+    saturation = 0.1;
+  }
+  if (saturation < 0.06) {
+    saturation = 0.06;
+  }
+  return Math.round(saturation * 100) / 100;
+}
+function getValue(hsv, i, light) {
+  var value;
+  if (light) {
+    value = hsv.v + brightnessStep1 * i;
+  } else {
+    value = hsv.v - brightnessStep2 * i;
+  }
+  value = Math.max(0, Math.min(1, value));
+  return Math.round(value * 100) / 100;
+}
+function generate(color) {
+  var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var patterns = [];
+  var pColor = new FastColor(color);
+  var hsv = pColor.toHsv();
+  for (var i = lightColorCount; i > 0; i -= 1) {
+    var c = new FastColor({
+      h: getHue(hsv, i, true),
+      s: getSaturation(hsv, i, true),
+      v: getValue(hsv, i, true)
+    });
+    patterns.push(c);
+  }
+  patterns.push(pColor);
+  for (var _i = 1; _i <= darkColorCount; _i += 1) {
+    var _c = new FastColor({
+      h: getHue(hsv, _i),
+      s: getSaturation(hsv, _i),
+      v: getValue(hsv, _i)
+    });
+    patterns.push(_c);
+  }
+  if (opts.theme === "dark") {
+    return darkColorMap.map(function(_ref) {
+      var index = _ref.index, amount = _ref.amount;
+      return new FastColor(opts.backgroundColor || "#141414").mix(patterns[index], amount).toHexString();
+    });
+  }
+  return patterns.map(function(c2) {
+    return c2.toHexString();
+  });
+}
+var hueStep, saturationStep, saturationStep2, brightnessStep1, brightnessStep2, lightColorCount, darkColorCount, darkColorMap;
+var init_generate = __esm({
+  "node_modules/@ant-design/colors/es/generate.js"() {
+    init_es();
+    hueStep = 2;
+    saturationStep = 0.16;
+    saturationStep2 = 0.05;
+    brightnessStep1 = 0.05;
+    brightnessStep2 = 0.15;
+    lightColorCount = 5;
+    darkColorCount = 4;
+    darkColorMap = [{
+      index: 7,
+      amount: 15
+    }, {
+      index: 6,
+      amount: 25
+    }, {
+      index: 5,
+      amount: 30
+    }, {
+      index: 5,
+      amount: 45
+    }, {
+      index: 5,
+      amount: 65
+    }, {
+      index: 5,
+      amount: 85
+    }, {
+      index: 4,
+      amount: 90
+    }, {
+      index: 3,
+      amount: 95
+    }, {
+      index: 2,
+      amount: 97
+    }, {
+      index: 1,
+      amount: 98
+    }];
+  }
+});
+
+// node_modules/@ant-design/colors/es/presets.js
+var presetPrimaryColors, red, volcano, orange, gold, yellow, lime, green, cyan, blue, geekblue, purple, magenta, grey, gray, presetPalettes, redDark, volcanoDark, orangeDark, goldDark, yellowDark, limeDark, greenDark, cyanDark, blueDark, geekblueDark, purpleDark, magentaDark, greyDark, presetDarkPalettes;
+var init_presets = __esm({
+  "node_modules/@ant-design/colors/es/presets.js"() {
+    presetPrimaryColors = {
+      "red": "#F5222D",
+      "volcano": "#FA541C",
+      "orange": "#FA8C16",
+      "gold": "#FAAD14",
+      "yellow": "#FADB14",
+      "lime": "#A0D911",
+      "green": "#52C41A",
+      "cyan": "#13C2C2",
+      "blue": "#1677FF",
+      "geekblue": "#2F54EB",
+      "purple": "#722ED1",
+      "magenta": "#EB2F96",
+      "grey": "#666666"
+    };
+    red = ["#fff1f0", "#ffccc7", "#ffa39e", "#ff7875", "#ff4d4f", "#f5222d", "#cf1322", "#a8071a", "#820014", "#5c0011"];
+    red.primary = red[5];
+    volcano = ["#fff2e8", "#ffd8bf", "#ffbb96", "#ff9c6e", "#ff7a45", "#fa541c", "#d4380d", "#ad2102", "#871400", "#610b00"];
+    volcano.primary = volcano[5];
+    orange = ["#fff7e6", "#ffe7ba", "#ffd591", "#ffc069", "#ffa940", "#fa8c16", "#d46b08", "#ad4e00", "#873800", "#612500"];
+    orange.primary = orange[5];
+    gold = ["#fffbe6", "#fff1b8", "#ffe58f", "#ffd666", "#ffc53d", "#faad14", "#d48806", "#ad6800", "#874d00", "#613400"];
+    gold.primary = gold[5];
+    yellow = ["#feffe6", "#ffffb8", "#fffb8f", "#fff566", "#ffec3d", "#fadb14", "#d4b106", "#ad8b00", "#876800", "#614700"];
+    yellow.primary = yellow[5];
+    lime = ["#fcffe6", "#f4ffb8", "#eaff8f", "#d3f261", "#bae637", "#a0d911", "#7cb305", "#5b8c00", "#3f6600", "#254000"];
+    lime.primary = lime[5];
+    green = ["#f6ffed", "#d9f7be", "#b7eb8f", "#95de64", "#73d13d", "#52c41a", "#389e0d", "#237804", "#135200", "#092b00"];
+    green.primary = green[5];
+    cyan = ["#e6fffb", "#b5f5ec", "#87e8de", "#5cdbd3", "#36cfc9", "#13c2c2", "#08979c", "#006d75", "#00474f", "#002329"];
+    cyan.primary = cyan[5];
+    blue = ["#e6f4ff", "#bae0ff", "#91caff", "#69b1ff", "#4096ff", "#1677ff", "#0958d9", "#003eb3", "#002c8c", "#001d66"];
+    blue.primary = blue[5];
+    geekblue = ["#f0f5ff", "#d6e4ff", "#adc6ff", "#85a5ff", "#597ef7", "#2f54eb", "#1d39c4", "#10239e", "#061178", "#030852"];
+    geekblue.primary = geekblue[5];
+    purple = ["#f9f0ff", "#efdbff", "#d3adf7", "#b37feb", "#9254de", "#722ed1", "#531dab", "#391085", "#22075e", "#120338"];
+    purple.primary = purple[5];
+    magenta = ["#fff0f6", "#ffd6e7", "#ffadd2", "#ff85c0", "#f759ab", "#eb2f96", "#c41d7f", "#9e1068", "#780650", "#520339"];
+    magenta.primary = magenta[5];
+    grey = ["#a6a6a6", "#999999", "#8c8c8c", "#808080", "#737373", "#666666", "#404040", "#1a1a1a", "#000000", "#000000"];
+    grey.primary = grey[5];
+    gray = grey;
+    presetPalettes = {
+      red,
+      volcano,
+      orange,
+      gold,
+      yellow,
+      lime,
+      green,
+      cyan,
+      blue,
+      geekblue,
+      purple,
+      magenta,
+      grey
+    };
+    redDark = ["#2a1215", "#431418", "#58181c", "#791a1f", "#a61d24", "#d32029", "#e84749", "#f37370", "#f89f9a", "#fac8c3"];
+    redDark.primary = redDark[5];
+    volcanoDark = ["#2b1611", "#441d12", "#592716", "#7c3118", "#aa3e19", "#d84a1b", "#e87040", "#f3956a", "#f8b692", "#fad4bc"];
+    volcanoDark.primary = volcanoDark[5];
+    orangeDark = ["#2b1d11", "#442a11", "#593815", "#7c4a15", "#aa6215", "#d87a16", "#e89a3c", "#f3b765", "#f8cf8d", "#fae3b7"];
+    orangeDark.primary = orangeDark[5];
+    goldDark = ["#2b2111", "#443111", "#594214", "#7c5914", "#aa7714", "#d89614", "#e8b339", "#f3cc62", "#f8df8b", "#faedb5"];
+    goldDark.primary = goldDark[5];
+    yellowDark = ["#2b2611", "#443b11", "#595014", "#7c6e14", "#aa9514", "#d8bd14", "#e8d639", "#f3ea62", "#f8f48b", "#fafab5"];
+    yellowDark.primary = yellowDark[5];
+    limeDark = ["#1f2611", "#2e3c10", "#3e4f13", "#536d13", "#6f9412", "#8bbb11", "#a9d134", "#c9e75d", "#e4f88b", "#f0fab5"];
+    limeDark.primary = limeDark[5];
+    greenDark = ["#162312", "#1d3712", "#274916", "#306317", "#3c8618", "#49aa19", "#6abe39", "#8fd460", "#b2e58b", "#d5f2bb"];
+    greenDark.primary = greenDark[5];
+    cyanDark = ["#112123", "#113536", "#144848", "#146262", "#138585", "#13a8a8", "#33bcb7", "#58d1c9", "#84e2d8", "#b2f1e8"];
+    cyanDark.primary = cyanDark[5];
+    blueDark = ["#111a2c", "#112545", "#15325b", "#15417e", "#1554ad", "#1668dc", "#3c89e8", "#65a9f3", "#8dc5f8", "#b7dcfa"];
+    blueDark.primary = blueDark[5];
+    geekblueDark = ["#131629", "#161d40", "#1c2755", "#203175", "#263ea0", "#2b4acb", "#5273e0", "#7f9ef3", "#a8c1f8", "#d2e0fa"];
+    geekblueDark.primary = geekblueDark[5];
+    purpleDark = ["#1a1325", "#24163a", "#301c4d", "#3e2069", "#51258f", "#642ab5", "#854eca", "#ab7ae0", "#cda8f0", "#ebd7fa"];
+    purpleDark.primary = purpleDark[5];
+    magentaDark = ["#291321", "#40162f", "#551c3b", "#75204f", "#a02669", "#cb2b83", "#e0529c", "#f37fb7", "#f8a8cc", "#fad2e3"];
+    magentaDark.primary = magentaDark[5];
+    greyDark = ["#151515", "#1f1f1f", "#2d2d2d", "#393939", "#494949", "#5a5a5a", "#6a6a6a", "#7b7b7b", "#888888", "#969696"];
+    greyDark.primary = greyDark[5];
+    presetDarkPalettes = {
+      red: redDark,
+      volcano: volcanoDark,
+      orange: orangeDark,
+      gold: goldDark,
+      yellow: yellowDark,
+      lime: limeDark,
+      green: greenDark,
+      cyan: cyanDark,
+      blue: blueDark,
+      geekblue: geekblueDark,
+      purple: purpleDark,
+      magenta: magentaDark,
+      grey: greyDark
+    };
+  }
+});
+
+// node_modules/@ant-design/colors/es/index.js
+var es_exports = {};
+__export(es_exports, {
+  blue: () => blue,
+  blueDark: () => blueDark,
+  cyan: () => cyan,
+  cyanDark: () => cyanDark,
+  geekblue: () => geekblue,
+  geekblueDark: () => geekblueDark,
+  generate: () => generate,
+  gold: () => gold,
+  goldDark: () => goldDark,
+  gray: () => gray,
+  green: () => green,
+  greenDark: () => greenDark,
+  grey: () => grey,
+  greyDark: () => greyDark,
+  lime: () => lime,
+  limeDark: () => limeDark,
+  magenta: () => magenta,
+  magentaDark: () => magentaDark,
+  orange: () => orange,
+  orangeDark: () => orangeDark,
+  presetDarkPalettes: () => presetDarkPalettes,
+  presetPalettes: () => presetPalettes,
+  presetPrimaryColors: () => presetPrimaryColors,
+  purple: () => purple,
+  purpleDark: () => purpleDark,
+  red: () => red,
+  redDark: () => redDark,
+  volcano: () => volcano,
+  volcanoDark: () => volcanoDark,
+  yellow: () => yellow,
+  yellowDark: () => yellowDark
+});
+var init_es2 = __esm({
+  "node_modules/@ant-design/colors/es/index.js"() {
+    init_generate();
+    init_presets();
+  }
+});
+
+export {
+  FastColor,
+  init_es,
+  generate,
+  presetPrimaryColors,
+  red,
+  volcano,
+  orange,
+  gold,
+  yellow,
+  lime,
+  green,
+  cyan,
+  blue,
+  geekblue,
+  purple,
+  magenta,
+  grey,
+  gray,
+  presetPalettes,
+  redDark,
+  volcanoDark,
+  orangeDark,
+  goldDark,
+  yellowDark,
+  limeDark,
+  greenDark,
+  cyanDark,
+  blueDark,
+  geekblueDark,
+  purpleDark,
+  magentaDark,
+  greyDark,
+  presetDarkPalettes,
+  es_exports,
+  init_es2
+};
+//# sourceMappingURL=chunk-5T3YOWZX.js.map

web/node_modules/.vite/deps/chunk-7KEXXFT5.js

@@ -0,0 +1,54 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/dayjs/plugin/relativeTime.js
+var require_relativeTime = __commonJS({
+  "node_modules/dayjs/plugin/relativeTime.js"(exports, module) {
+    !(function(r, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (r = "undefined" != typeof globalThis ? globalThis : r || self).dayjs_plugin_relativeTime = e();
+    })(exports, (function() {
+      "use strict";
+      return function(r, e, t) {
+        r = r || {};
+        var n = e.prototype, o = { future: "in %s", past: "%s ago", s: "a few seconds", m: "a minute", mm: "%d minutes", h: "an hour", hh: "%d hours", d: "a day", dd: "%d days", M: "a month", MM: "%d months", y: "a year", yy: "%d years" };
+        function i(r2, e2, t2, o2) {
+          return n.fromToBase(r2, e2, t2, o2);
+        }
+        t.en.relativeTime = o, n.fromToBase = function(e2, n2, i2, d2, u) {
+          for (var f, a, s, l = i2.$locale().relativeTime || o, h = r.thresholds || [{ l: "s", r: 44, d: "second" }, { l: "m", r: 89 }, { l: "mm", r: 44, d: "minute" }, { l: "h", r: 89 }, { l: "hh", r: 21, d: "hour" }, { l: "d", r: 35 }, { l: "dd", r: 25, d: "day" }, { l: "M", r: 45 }, { l: "MM", r: 10, d: "month" }, { l: "y", r: 17 }, { l: "yy", d: "year" }], m = h.length, c = 0; c < m; c += 1) {
+            var y = h[c];
+            y.d && (f = d2 ? t(e2).diff(i2, y.d, true) : i2.diff(e2, y.d, true));
+            var p = (r.rounding || Math.round)(Math.abs(f));
+            if (s = f > 0, p <= y.r || !y.r) {
+              p <= 1 && c > 0 && (y = h[c - 1]);
+              var v = l[y.l];
+              u && (p = u("" + p)), a = "string" == typeof v ? v.replace("%d", p) : v(p, n2, y.l, s);
+              break;
+            }
+          }
+          if (n2) return a;
+          var M = s ? l.future : l.past;
+          return "function" == typeof M ? M(a) : M.replace("%s", a);
+        }, n.to = function(r2, e2) {
+          return i(r2, e2, this, true);
+        }, n.from = function(r2, e2) {
+          return i(r2, e2, this);
+        };
+        var d = function(r2) {
+          return r2.$u ? t.utc() : t();
+        };
+        n.toNow = function(r2) {
+          return this.to(d(this), r2);
+        }, n.fromNow = function(r2) {
+          return this.from(d(this), r2);
+        };
+      };
+    }));
+  }
+});
+
+export {
+  require_relativeTime
+};
+//# sourceMappingURL=chunk-7KEXXFT5.js.map

web/node_modules/.vite/deps/chunk-7KEXXFT5.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../dayjs/plugin/relativeTime.js"],
+  "sourcesContent": ["!function(r,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(r=\"undefined\"!=typeof globalThis?globalThis:r||self).dayjs_plugin_relativeTime=e()}(this,(function(){\"use strict\";return function(r,e,t){r=r||{};var n=e.prototype,o={future:\"in %s\",past:\"%s ago\",s:\"a few seconds\",m:\"a minute\",mm:\"%d minutes\",h:\"an hour\",hh:\"%d hours\",d:\"a day\",dd:\"%d days\",M:\"a month\",MM:\"%d months\",y:\"a year\",yy:\"%d years\"};function i(r,e,t,o){return n.fromToBase(r,e,t,o)}t.en.relativeTime=o,n.fromToBase=function(e,n,i,d,u){for(var f,a,s,l=i.$locale().relativeTime||o,h=r.thresholds||[{l:\"s\",r:44,d:\"second\"},{l:\"m\",r:89},{l:\"mm\",r:44,d:\"minute\"},{l:\"h\",r:89},{l:\"hh\",r:21,d:\"hour\"},{l:\"d\",r:35},{l:\"dd\",r:25,d:\"day\"},{l:\"M\",r:45},{l:\"MM\",r:10,d:\"month\"},{l:\"y\",r:17},{l:\"yy\",d:\"year\"}],m=h.length,c=0;c<m;c+=1){var y=h[c];y.d&&(f=d?t(e).diff(i,y.d,!0):i.diff(e,y.d,!0));var p=(r.rounding||Math.round)(Math.abs(f));if(s=f>0,p<=y.r||!y.r){p<=1&&c>0&&(y=h[c-1]);var v=l[y.l];u&&(p=u(\"\"+p)),a=\"string\"==typeof v?v.replace(\"%d\",p):v(p,n,y.l,s);break}}if(n)return a;var M=s?l.future:l.past;return\"function\"==typeof M?M(a):M.replace(\"%s\",a)},n.to=function(r,e){return i(r,e,this,!0)},n.from=function(r,e){return i(r,e,this)};var d=function(r){return r.$u?t.utc():t()};n.toNow=function(r){return this.to(d(this),r)},n.fromNow=function(r){return this.from(d(this),r)}}}));"],
+  "mappings": ";;;;;AAAA;AAAA;AAAA,MAAC,SAAS,GAAE,GAAE;AAAC,kBAAU,OAAO,WAAS,eAAa,OAAO,SAAO,OAAO,UAAQ,EAAE,IAAE,cAAY,OAAO,UAAQ,OAAO,MAAI,OAAO,CAAC,KAAG,IAAE,eAAa,OAAO,aAAW,aAAW,KAAG,MAAM,4BAA0B,EAAE;AAAA,IAAC,GAAE,UAAM,WAAU;AAAC;AAAa,aAAO,SAAS,GAAE,GAAE,GAAE;AAAC,YAAE,KAAG,CAAC;AAAE,YAAI,IAAE,EAAE,WAAU,IAAE,EAAC,QAAO,SAAQ,MAAK,UAAS,GAAE,iBAAgB,GAAE,YAAW,IAAG,cAAa,GAAE,WAAU,IAAG,YAAW,GAAE,SAAQ,IAAG,WAAU,GAAE,WAAU,IAAG,aAAY,GAAE,UAAS,IAAG,WAAU;AAAE,iBAAS,EAAEA,IAAEC,IAAEC,IAAEC,IAAE;AAAC,iBAAO,EAAE,WAAWH,IAAEC,IAAEC,IAAEC,EAAC;AAAA,QAAC;AAAC,UAAE,GAAG,eAAa,GAAE,EAAE,aAAW,SAASF,IAAEG,IAAEC,IAAEC,IAAE,GAAE;AAAC,mBAAQ,GAAE,GAAE,GAAE,IAAED,GAAE,QAAQ,EAAE,gBAAc,GAAE,IAAE,EAAE,cAAY,CAAC,EAAC,GAAE,KAAI,GAAE,IAAG,GAAE,SAAQ,GAAE,EAAC,GAAE,KAAI,GAAE,GAAE,GAAE,EAAC,GAAE,MAAK,GAAE,IAAG,GAAE,SAAQ,GAAE,EAAC,GAAE,KAAI,GAAE,GAAE,GAAE,EAAC,GAAE,MAAK,GAAE,IAAG,GAAE,OAAM,GAAE,EAAC,GAAE,KAAI,GAAE,GAAE,GAAE,EAAC,GAAE,MAAK,GAAE,IAAG,GAAE,MAAK,GAAE,EAAC,GAAE,KAAI,GAAE,GAAE,GAAE,EAAC,GAAE,MAAK,GAAE,IAAG,GAAE,QAAO,GAAE,EAAC,GAAE,KAAI,GAAE,GAAE,GAAE,EAAC,GAAE,MAAK,GAAE,OAAM,CAAC,GAAE,IAAE,EAAE,QAAO,IAAE,GAAE,IAAE,GAAE,KAAG,GAAE;AAAC,gBAAI,IAAE,EAAE,CAAC;AAAE,cAAE,MAAI,IAAEC,KAAE,EAAEL,EAAC,EAAE,KAAKI,IAAE,EAAE,GAAE,IAAE,IAAEA,GAAE,KAAKJ,IAAE,EAAE,GAAE,IAAE;AAAG,gBAAI,KAAG,EAAE,YAAU,KAAK,OAAO,KAAK,IAAI,CAAC,CAAC;AAAE,gBAAG,IAAE,IAAE,GAAE,KAAG,EAAE,KAAG,CAAC,EAAE,GAAE;AAAC,mBAAG,KAAG,IAAE,MAAI,IAAE,EAAE,IAAE,CAAC;AAAG,kBAAI,IAAE,EAAE,EAAE,CAAC;AAAE,oBAAI,IAAE,EAAE,KAAG,CAAC,IAAG,IAAE,YAAU,OAAO,IAAE,EAAE,QAAQ,MAAK,CAAC,IAAE,EAAE,GAAEG,IAAE,EAAE,GAAE,CAAC;AAAE;AAAA,YAAK;AAAA,UAAC;AAAC,cAAGA,GAAE,QAAO;AAAE,cAAI,IAAE,IAAE,EAAE,SAAO,EAAE;AAAK,iBAAM,cAAY,OAAO,IAAE,EAAE,CAAC,IAAE,EAAE,QAAQ,MAAK,CAAC;AAAA,QAAC,GAAE,EAAE,KAAG,SAASJ,IAAEC,IAAE;AAAC,iBAAO,EAAED,IAAEC,IAAE,MAAK,IAAE;AAAA,QAAC,GAAE,EAAE,OAAK,SAASD,IAAEC,IAAE;AAAC,iBAAO,EAAED,IAAEC,IAAE,IAAI;AAAA,QAAC;AAAE,YAAI,IAAE,SAASD,IAAE;AAAC,iBAAOA,GAAE,KAAG,EAAE,IAAI,IAAE,EAAE;AAAA,QAAC;AAAE,UAAE,QAAM,SAASA,IAAE;AAAC,iBAAO,KAAK,GAAG,EAAE,IAAI,GAAEA,EAAC;AAAA,QAAC,GAAE,EAAE,UAAQ,SAASA,IAAE;AAAC,iBAAO,KAAK,KAAK,EAAE,IAAI,GAAEA,EAAC;AAAA,QAAC;AAAA,MAAC;AAAA,IAAC,EAAE;AAAA;AAAA;",
+  "names": ["r", "e", "t", "o", "n", "i", "d"]
+}

web/node_modules/.vite/deps/chunk-ARCWD47H.js

@@ -0,0 +1,142 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/toggle-selection/index.js
+var require_toggle_selection = __commonJS({
+  "node_modules/toggle-selection/index.js"(exports, module) {
+    module.exports = function() {
+      var selection = document.getSelection();
+      if (!selection.rangeCount) {
+        return function() {
+        };
+      }
+      var active = document.activeElement;
+      var ranges = [];
+      for (var i = 0; i < selection.rangeCount; i++) {
+        ranges.push(selection.getRangeAt(i));
+      }
+      switch (active.tagName.toUpperCase()) {
+        // .toUpperCase handles XHTML
+        case "INPUT":
+        case "TEXTAREA":
+          active.blur();
+          break;
+        default:
+          active = null;
+          break;
+      }
+      selection.removeAllRanges();
+      return function() {
+        selection.type === "Caret" && selection.removeAllRanges();
+        if (!selection.rangeCount) {
+          ranges.forEach(function(range) {
+            selection.addRange(range);
+          });
+        }
+        active && active.focus();
+      };
+    };
+  }
+});
+
+// node_modules/copy-to-clipboard/index.js
+var require_copy_to_clipboard = __commonJS({
+  "node_modules/copy-to-clipboard/index.js"(exports, module) {
+    var deselectCurrent = require_toggle_selection();
+    var clipboardToIE11Formatting = {
+      "text/plain": "Text",
+      "text/html": "Url",
+      "default": "Text"
+    };
+    var defaultMessage = "Copy to clipboard: #{key}, Enter";
+    function format(message) {
+      var copyKey = (/mac os x/i.test(navigator.userAgent) ? "⌘" : "Ctrl") + "+C";
+      return message.replace(/#{\s*key\s*}/g, copyKey);
+    }
+    function copy(text, options) {
+      var debug, message, reselectPrevious, range, selection, mark, success = false;
+      if (!options) {
+        options = {};
+      }
+      debug = options.debug || false;
+      try {
+        reselectPrevious = deselectCurrent();
+        range = document.createRange();
+        selection = document.getSelection();
+        mark = document.createElement("span");
+        mark.textContent = text;
+        mark.ariaHidden = "true";
+        mark.style.all = "unset";
+        mark.style.position = "fixed";
+        mark.style.top = 0;
+        mark.style.clip = "rect(0, 0, 0, 0)";
+        mark.style.whiteSpace = "pre";
+        mark.style.webkitUserSelect = "text";
+        mark.style.MozUserSelect = "text";
+        mark.style.msUserSelect = "text";
+        mark.style.userSelect = "text";
+        mark.addEventListener("copy", function(e) {
+          e.stopPropagation();
+          if (options.format) {
+            e.preventDefault();
+            if (typeof e.clipboardData === "undefined") {
+              debug && console.warn("unable to use e.clipboardData");
+              debug && console.warn("trying IE specific stuff");
+              window.clipboardData.clearData();
+              var format2 = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting["default"];
+              window.clipboardData.setData(format2, text);
+            } else {
+              e.clipboardData.clearData();
+              e.clipboardData.setData(options.format, text);
+            }
+          }
+          if (options.onCopy) {
+            e.preventDefault();
+            options.onCopy(e.clipboardData);
+          }
+        });
+        document.body.appendChild(mark);
+        range.selectNodeContents(mark);
+        selection.addRange(range);
+        var successful = document.execCommand("copy");
+        if (!successful) {
+          throw new Error("copy command was unsuccessful");
+        }
+        success = true;
+      } catch (err) {
+        debug && console.error("unable to copy using execCommand: ", err);
+        debug && console.warn("trying IE specific stuff");
+        try {
+          window.clipboardData.setData(options.format || "text", text);
+          options.onCopy && options.onCopy(window.clipboardData);
+          success = true;
+        } catch (err2) {
+          debug && console.error("unable to copy using clipboardData: ", err2);
+          debug && console.error("falling back to prompt");
+          message = format("message" in options ? options.message : defaultMessage);
+          window.prompt(message, text);
+        }
+      } finally {
+        if (selection) {
+          if (typeof selection.removeRange == "function") {
+            selection.removeRange(range);
+          } else {
+            selection.removeAllRanges();
+          }
+        }
+        if (mark) {
+          document.body.removeChild(mark);
+        }
+        reselectPrevious();
+      }
+      return success;
+    }
+    module.exports = copy;
+  }
+});
+
+export {
+  require_copy_to_clipboard
+};
+//# sourceMappingURL=chunk-ARCWD47H.js.map

web/node_modules/.vite/deps/chunk-ARCWD47H.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../toggle-selection/index.js", "../../copy-to-clipboard/index.js"],
+  "sourcesContent": ["\nmodule.exports = function () {\n  var selection = document.getSelection();\n  if (!selection.rangeCount) {\n    return function () {};\n  }\n  var active = document.activeElement;\n\n  var ranges = [];\n  for (var i = 0; i < selection.rangeCount; i++) {\n    ranges.push(selection.getRangeAt(i));\n  }\n\n  switch (active.tagName.toUpperCase()) { // .toUpperCase handles XHTML\n    case 'INPUT':\n    case 'TEXTAREA':\n      active.blur();\n      break;\n\n    default:\n      active = null;\n      break;\n  }\n\n  selection.removeAllRanges();\n  return function () {\n    selection.type === 'Caret' &&\n    selection.removeAllRanges();\n\n    if (!selection.rangeCount) {\n      ranges.forEach(function(range) {\n        selection.addRange(range);\n      });\n    }\n\n    active &&\n    active.focus();\n  };\n};\n", "\"use strict\";\n\nvar deselectCurrent = require(\"toggle-selection\");\n\nvar clipboardToIE11Formatting = {\n  \"text/plain\": \"Text\",\n  \"text/html\": \"Url\",\n  \"default\": \"Text\"\n}\n\nvar defaultMessage = \"Copy to clipboard: #{key}, Enter\";\n\nfunction format(message) {\n  var copyKey = (/mac os x/i.test(navigator.userAgent) ? \"⌘\" : \"Ctrl\") + \"+C\";\n  return message.replace(/#{\\s*key\\s*}/g, copyKey);\n}\n\nfunction copy(text, options) {\n  var debug,\n    message,\n    reselectPrevious,\n    range,\n    selection,\n    mark,\n    success = false;\n  if (!options) {\n    options = {};\n  }\n  debug = options.debug || false;\n  try {\n    reselectPrevious = deselectCurrent();\n\n    range = document.createRange();\n    selection = document.getSelection();\n\n    mark = document.createElement(\"span\");\n    mark.textContent = text;\n    // avoid screen readers from reading out loud the text\n    mark.ariaHidden = \"true\"\n    // reset user styles for span element\n    mark.style.all = \"unset\";\n    // prevents scrolling to the end of the page\n    mark.style.position = \"fixed\";\n    mark.style.top = 0;\n    mark.style.clip = \"rect(0, 0, 0, 0)\";\n    // used to preserve spaces and line breaks\n    mark.style.whiteSpace = \"pre\";\n    // do not inherit user-select (it may be `none`)\n    mark.style.webkitUserSelect = \"text\";\n    mark.style.MozUserSelect = \"text\";\n    mark.style.msUserSelect = \"text\";\n    mark.style.userSelect = \"text\";\n    mark.addEventListener(\"copy\", function(e) {\n      e.stopPropagation();\n      if (options.format) {\n        e.preventDefault();\n        if (typeof e.clipboardData === \"undefined\") { // IE 11\n          debug && console.warn(\"unable to use e.clipboardData\");\n          debug && console.warn(\"trying IE specific stuff\");\n          window.clipboardData.clearData();\n          var format = clipboardToIE11Formatting[options.format] || clipboardToIE11Formatting[\"default\"]\n          window.clipboardData.setData(format, text);\n        } else { // all other browsers\n          e.clipboardData.clearData();\n          e.clipboardData.setData(options.format, text);\n        }\n      }\n      if (options.onCopy) {\n        e.preventDefault();\n        options.onCopy(e.clipboardData);\n      }\n    });\n\n    document.body.appendChild(mark);\n\n    range.selectNodeContents(mark);\n    selection.addRange(range);\n\n    var successful = document.execCommand(\"copy\");\n    if (!successful) {\n      throw new Error(\"copy command was unsuccessful\");\n    }\n    success = true;\n  } catch (err) {\n    debug && console.error(\"unable to copy using execCommand: \", err);\n    debug && console.warn(\"trying IE specific stuff\");\n    try {\n      window.clipboardData.setData(options.format || \"text\", text);\n      options.onCopy && options.onCopy(window.clipboardData);\n      success = true;\n    } catch (err) {\n      debug && console.error(\"unable to copy using clipboardData: \", err);\n      debug && console.error(\"falling back to prompt\");\n      message = format(\"message\" in options ? options.message : defaultMessage);\n      window.prompt(message, text);\n    }\n  } finally {\n    if (selection) {\n      if (typeof selection.removeRange == \"function\") {\n        selection.removeRange(range);\n      } else {\n        selection.removeAllRanges();\n      }\n    }\n\n    if (mark) {\n      document.body.removeChild(mark);\n    }\n    reselectPrevious();\n  }\n\n  return success;\n}\n\nmodule.exports = copy;\n"],
+  "mappings": ";;;;;AAAA;AAAA;AACA,WAAO,UAAU,WAAY;AAC3B,UAAI,YAAY,SAAS,aAAa;AACtC,UAAI,CAAC,UAAU,YAAY;AACzB,eAAO,WAAY;AAAA,QAAC;AAAA,MACtB;AACA,UAAI,SAAS,SAAS;AAEtB,UAAI,SAAS,CAAC;AACd,eAAS,IAAI,GAAG,IAAI,UAAU,YAAY,KAAK;AAC7C,eAAO,KAAK,UAAU,WAAW,CAAC,CAAC;AAAA,MACrC;AAEA,cAAQ,OAAO,QAAQ,YAAY,GAAG;AAAA;AAAA,QACpC,KAAK;AAAA,QACL,KAAK;AACH,iBAAO,KAAK;AACZ;AAAA,QAEF;AACE,mBAAS;AACT;AAAA,MACJ;AAEA,gBAAU,gBAAgB;AAC1B,aAAO,WAAY;AACjB,kBAAU,SAAS,WACnB,UAAU,gBAAgB;AAE1B,YAAI,CAAC,UAAU,YAAY;AACzB,iBAAO,QAAQ,SAAS,OAAO;AAC7B,sBAAU,SAAS,KAAK;AAAA,UAC1B,CAAC;AAAA,QACH;AAEA,kBACA,OAAO,MAAM;AAAA,MACf;AAAA,IACF;AAAA;AAAA;;;ACtCA;AAAA;AAEA,QAAI,kBAAkB;AAEtB,QAAI,4BAA4B;AAAA,MAC9B,cAAc;AAAA,MACd,aAAa;AAAA,MACb,WAAW;AAAA,IACb;AAEA,QAAI,iBAAiB;AAErB,aAAS,OAAO,SAAS;AACvB,UAAI,WAAW,YAAY,KAAK,UAAU,SAAS,IAAI,MAAM,UAAU;AACvE,aAAO,QAAQ,QAAQ,iBAAiB,OAAO;AAAA,IACjD;AAEA,aAAS,KAAK,MAAM,SAAS;AAC3B,UAAI,OACF,SACA,kBACA,OACA,WACA,MACA,UAAU;AACZ,UAAI,CAAC,SAAS;AACZ,kBAAU,CAAC;AAAA,MACb;AACA,cAAQ,QAAQ,SAAS;AACzB,UAAI;AACF,2BAAmB,gBAAgB;AAEnC,gBAAQ,SAAS,YAAY;AAC7B,oBAAY,SAAS,aAAa;AAElC,eAAO,SAAS,cAAc,MAAM;AACpC,aAAK,cAAc;AAEnB,aAAK,aAAa;AAElB,aAAK,MAAM,MAAM;AAEjB,aAAK,MAAM,WAAW;AACtB,aAAK,MAAM,MAAM;AACjB,aAAK,MAAM,OAAO;AAElB,aAAK,MAAM,aAAa;AAExB,aAAK,MAAM,mBAAmB;AAC9B,aAAK,MAAM,gBAAgB;AAC3B,aAAK,MAAM,eAAe;AAC1B,aAAK,MAAM,aAAa;AACxB,aAAK,iBAAiB,QAAQ,SAAS,GAAG;AACxC,YAAE,gBAAgB;AAClB,cAAI,QAAQ,QAAQ;AAClB,cAAE,eAAe;AACjB,gBAAI,OAAO,EAAE,kBAAkB,aAAa;AAC1C,uBAAS,QAAQ,KAAK,+BAA+B;AACrD,uBAAS,QAAQ,KAAK,0BAA0B;AAChD,qBAAO,cAAc,UAAU;AAC/B,kBAAIA,UAAS,0BAA0B,QAAQ,MAAM,KAAK,0BAA0B,SAAS;AAC7F,qBAAO,cAAc,QAAQA,SAAQ,IAAI;AAAA,YAC3C,OAAO;AACL,gBAAE,cAAc,UAAU;AAC1B,gBAAE,cAAc,QAAQ,QAAQ,QAAQ,IAAI;AAAA,YAC9C;AAAA,UACF;AACA,cAAI,QAAQ,QAAQ;AAClB,cAAE,eAAe;AACjB,oBAAQ,OAAO,EAAE,aAAa;AAAA,UAChC;AAAA,QACF,CAAC;AAED,iBAAS,KAAK,YAAY,IAAI;AAE9B,cAAM,mBAAmB,IAAI;AAC7B,kBAAU,SAAS,KAAK;AAExB,YAAI,aAAa,SAAS,YAAY,MAAM;AAC5C,YAAI,CAAC,YAAY;AACf,gBAAM,IAAI,MAAM,+BAA+B;AAAA,QACjD;AACA,kBAAU;AAAA,MACZ,SAAS,KAAK;AACZ,iBAAS,QAAQ,MAAM,sCAAsC,GAAG;AAChE,iBAAS,QAAQ,KAAK,0BAA0B;AAChD,YAAI;AACF,iBAAO,cAAc,QAAQ,QAAQ,UAAU,QAAQ,IAAI;AAC3D,kBAAQ,UAAU,QAAQ,OAAO,OAAO,aAAa;AACrD,oBAAU;AAAA,QACZ,SAASC,MAAK;AACZ,mBAAS,QAAQ,MAAM,wCAAwCA,IAAG;AAClE,mBAAS,QAAQ,MAAM,wBAAwB;AAC/C,oBAAU,OAAO,aAAa,UAAU,QAAQ,UAAU,cAAc;AACxE,iBAAO,OAAO,SAAS,IAAI;AAAA,QAC7B;AAAA,MACF,UAAE;AACA,YAAI,WAAW;AACb,cAAI,OAAO,UAAU,eAAe,YAAY;AAC9C,sBAAU,YAAY,KAAK;AAAA,UAC7B,OAAO;AACL,sBAAU,gBAAgB;AAAA,UAC5B;AAAA,QACF;AAEA,YAAI,MAAM;AACR,mBAAS,KAAK,YAAY,IAAI;AAAA,QAChC;AACA,yBAAiB;AAAA,MACnB;AAEA,aAAO;AAAA,IACT;AAEA,WAAO,UAAU;AAAA;AAAA;",
+  "names": ["format", "err"]
+}

web/node_modules/.vite/deps/chunk-EAZ3M6A4.js

@@ -0,0 +1,77 @@
+import {
+  editor
+} from "./chunk-GUNMJBQ5.js";
+
+// node_modules/monaco-editor/esm/vs/common/workers.js
+import "E:/Code/terminal/next-terminal-1.3.9/web/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon.css";
+import "E:/Code/terminal/next-terminal-1.3.9/web/node_modules/monaco-editor/esm/vs/base/browser/ui/codicons/codicon/codicon-modifiers.css";
+function createTrustedTypesPolicy(policyName, policyOptions) {
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment?.createTrustedTypesPolicy) {
+    try {
+      return monacoEnvironment.createTrustedTypesPolicy(policyName, policyOptions);
+    } catch (err) {
+      console.error(err);
+      return void 0;
+    }
+  }
+  try {
+    return globalThis.trustedTypes?.createPolicy(policyName, policyOptions);
+  } catch (err) {
+    console.error(err);
+    return void 0;
+  }
+}
+var ttPolicy;
+if (typeof self === "object" && self.constructor && self.constructor.name === "DedicatedWorkerGlobalScope" && globalThis.workerttPolicy !== void 0) {
+  ttPolicy = globalThis.workerttPolicy;
+} else {
+  ttPolicy = createTrustedTypesPolicy("defaultWorkerFactory", {
+    createScriptURL: (value) => value
+  });
+}
+function getWorker(descriptor) {
+  const label = descriptor.label;
+  const monacoEnvironment = globalThis.MonacoEnvironment;
+  if (monacoEnvironment) {
+    if (typeof monacoEnvironment.getWorker === "function") {
+      return monacoEnvironment.getWorker("workerMain.js", label);
+    }
+    if (typeof monacoEnvironment.getWorkerUrl === "function") {
+      const workerUrl = monacoEnvironment.getWorkerUrl("workerMain.js", label);
+      return new Worker(
+        ttPolicy ? ttPolicy.createScriptURL(workerUrl) : workerUrl,
+        { name: label, type: "module" }
+      );
+    }
+  }
+  if (descriptor.createWorker) {
+    return descriptor.createWorker();
+  }
+  throw new Error(
+    `You must define a function MonacoEnvironment.getWorkerUrl or MonacoEnvironment.getWorker`
+  );
+}
+function createWebWorker(opts) {
+  const worker = Promise.resolve(
+    getWorker({
+      label: opts.label ?? "monaco-editor-worker",
+      moduleId: opts.moduleId,
+      createWorker: opts.createWorker
+    })
+  ).then((w) => {
+    w.postMessage("ignore");
+    w.postMessage(opts.createData);
+    return w;
+  });
+  return editor.createWebWorker({
+    worker,
+    host: opts.host,
+    keepIdleModels: opts.keepIdleModels
+  });
+}
+
+export {
+  createWebWorker
+};
+//# sourceMappingURL=chunk-EAZ3M6A4.js.map

web/node_modules/.vite/deps/chunk-FSGBSGQ2.js

@@ -0,0 +1,18 @@
+// node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
+function _assertThisInitialized(e) {
+  if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+
+// node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(t2, e2) {
+    return t2.__proto__ = e2, t2;
+  }, _setPrototypeOf(t, e);
+}
+
+export {
+  _assertThisInitialized,
+  _setPrototypeOf
+};
+//# sourceMappingURL=chunk-FSGBSGQ2.js.map

web/node_modules/.vite/deps/chunk-FSGBSGQ2.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../@babel/runtime/helpers/esm/assertThisInitialized.js", "../../@babel/runtime/helpers/esm/setPrototypeOf.js"],
+  "sourcesContent": ["function _assertThisInitialized(e) {\n  if (void 0 === e) throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  return e;\n}\nexport { _assertThisInitialized as default };", "function _setPrototypeOf(t, e) {\n  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {\n    return t.__proto__ = e, t;\n  }, _setPrototypeOf(t, e);\n}\nexport { _setPrototypeOf as default };"],
+  "mappings": ";AAAA,SAAS,uBAAuB,GAAG;AACjC,MAAI,WAAW,EAAG,OAAM,IAAI,eAAe,2DAA2D;AACtG,SAAO;AACT;;;ACHA,SAAS,gBAAgB,GAAG,GAAG;AAC7B,SAAO,kBAAkB,OAAO,iBAAiB,OAAO,eAAe,KAAK,IAAI,SAAUA,IAAGC,IAAG;AAC9F,WAAOD,GAAE,YAAYC,IAAGD;AAAA,EAC1B,GAAG,gBAAgB,GAAG,CAAC;AACzB;",
+  "names": ["t", "e"]
+}

web/node_modules/.vite/deps/chunk-KBMHTFOP.js

@@ -0,0 +1,319 @@
+import {
+  _objectWithoutPropertiesLoose
+} from "./chunk-4NTHFIFD.js";
+import {
+  require_react
+} from "./chunk-7ZNOTH45.js";
+import {
+  _defineProperty,
+  init_defineProperty
+} from "./chunk-R546NDVX.js";
+import {
+  __toESM
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+
+// node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+// node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+// node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+
+// node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o, r, i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+
+// node_modules/@babel/runtime/helpers/esm/objectSpread2.js
+init_defineProperty();
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+
+// node_modules/rc-util/es/Dom/canUseDom.js
+function canUseDom() {
+  return !!(typeof window !== "undefined" && window.document && window.document.createElement);
+}
+
+// node_modules/rc-util/es/Dom/contains.js
+function contains(root, n) {
+  if (!root) {
+    return false;
+  }
+  if (root.contains) {
+    return root.contains(n);
+  }
+  var node = n;
+  while (node) {
+    if (node === root) {
+      return true;
+    }
+    node = node.parentNode;
+  }
+  return false;
+}
+
+// node_modules/rc-util/es/Dom/dynamicCSS.js
+var APPEND_ORDER = "data-rc-order";
+var APPEND_PRIORITY = "data-rc-priority";
+var MARK_KEY = "rc-util-key";
+var containerCache = /* @__PURE__ */ new Map();
+function getMark() {
+  var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, mark = _ref.mark;
+  if (mark) {
+    return mark.startsWith("data-") ? mark : "data-".concat(mark);
+  }
+  return MARK_KEY;
+}
+function getContainer(option) {
+  if (option.attachTo) {
+    return option.attachTo;
+  }
+  var head = document.querySelector("head");
+  return head || document.body;
+}
+function getOrder(prepend) {
+  if (prepend === "queue") {
+    return "prependQueue";
+  }
+  return prepend ? "prepend" : "append";
+}
+function findStyles(container) {
+  return Array.from((containerCache.get(container) || container).children).filter(function(node) {
+    return node.tagName === "STYLE";
+  });
+}
+function injectCSS(css) {
+  var option = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  if (!canUseDom()) {
+    return null;
+  }
+  var csp = option.csp, prepend = option.prepend, _option$priority = option.priority, priority = _option$priority === void 0 ? 0 : _option$priority;
+  var mergedOrder = getOrder(prepend);
+  var isPrependQueue = mergedOrder === "prependQueue";
+  var styleNode = document.createElement("style");
+  styleNode.setAttribute(APPEND_ORDER, mergedOrder);
+  if (isPrependQueue && priority) {
+    styleNode.setAttribute(APPEND_PRIORITY, "".concat(priority));
+  }
+  if (csp !== null && csp !== void 0 && csp.nonce) {
+    styleNode.nonce = csp === null || csp === void 0 ? void 0 : csp.nonce;
+  }
+  styleNode.innerHTML = css;
+  var container = getContainer(option);
+  var firstChild = container.firstChild;
+  if (prepend) {
+    if (isPrependQueue) {
+      var existStyle = (option.styles || findStyles(container)).filter(function(node) {
+        if (!["prepend", "prependQueue"].includes(node.getAttribute(APPEND_ORDER))) {
+          return false;
+        }
+        var nodePriority = Number(node.getAttribute(APPEND_PRIORITY) || 0);
+        return priority >= nodePriority;
+      });
+      if (existStyle.length) {
+        container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
+        return styleNode;
+      }
+    }
+    container.insertBefore(styleNode, firstChild);
+  } else {
+    container.appendChild(styleNode);
+  }
+  return styleNode;
+}
+function findExistNode(key) {
+  var option = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var container = getContainer(option);
+  return (option.styles || findStyles(container)).find(function(node) {
+    return node.getAttribute(getMark(option)) === key;
+  });
+}
+function removeCSS(key) {
+  var option = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+  var existNode = findExistNode(key, option);
+  if (existNode) {
+    var container = getContainer(option);
+    container.removeChild(existNode);
+  }
+}
+function syncRealContainer(container, option) {
+  var cachedRealContainer = containerCache.get(container);
+  if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
+    var placeholderStyle = injectCSS("", option);
+    var parentNode = placeholderStyle.parentNode;
+    containerCache.set(container, parentNode);
+    container.removeChild(placeholderStyle);
+  }
+}
+function updateCSS(css, key) {
+  var originOption = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+  var container = getContainer(originOption);
+  var styles = findStyles(container);
+  var option = _objectSpread2(_objectSpread2({}, originOption), {}, {
+    styles
+  });
+  syncRealContainer(container, option);
+  var existNode = findExistNode(key, option);
+  if (existNode) {
+    var _option$csp, _option$csp2;
+    if ((_option$csp = option.csp) !== null && _option$csp !== void 0 && _option$csp.nonce && existNode.nonce !== ((_option$csp2 = option.csp) === null || _option$csp2 === void 0 ? void 0 : _option$csp2.nonce)) {
+      var _option$csp3;
+      existNode.nonce = (_option$csp3 = option.csp) === null || _option$csp3 === void 0 ? void 0 : _option$csp3.nonce;
+    }
+    if (existNode.innerHTML !== css) {
+      existNode.innerHTML = css;
+    }
+    return existNode;
+  }
+  var newNode = injectCSS(css, option);
+  newNode.setAttribute(getMark(option), key);
+  return newNode;
+}
+
+// node_modules/rc-util/es/warning.js
+var warned = {};
+var preWarningFns = [];
+var preMessage = function preMessage2(fn) {
+  preWarningFns.push(fn);
+};
+function warning(valid, message) {
+  if (!valid && console !== void 0) {
+    var finalMessage = preWarningFns.reduce(function(msg, preMessageFn) {
+      return preMessageFn(msg !== null && msg !== void 0 ? msg : "", "warning");
+    }, message);
+    if (finalMessage) {
+      console.error("Warning: ".concat(finalMessage));
+    }
+  }
+}
+function note(valid, message) {
+  if (!valid && console !== void 0) {
+    var finalMessage = preWarningFns.reduce(function(msg, preMessageFn) {
+      return preMessageFn(msg !== null && msg !== void 0 ? msg : "", "note");
+    }, message);
+    if (finalMessage) {
+      console.warn("Note: ".concat(finalMessage));
+    }
+  }
+}
+function resetWarned() {
+  warned = {};
+}
+function call(method, valid, message) {
+  if (!valid && !warned[message]) {
+    method(false, message);
+    warned[message] = true;
+  }
+}
+function warningOnce(valid, message) {
+  call(warning, valid, message);
+}
+function noteOnce(valid, message) {
+  call(note, valid, message);
+}
+warningOnce.preMessage = preMessage;
+warningOnce.resetWarned = resetWarned;
+warningOnce.noteOnce = noteOnce;
+var warning_default = warningOnce;
+
+// node_modules/rc-util/es/hooks/useMemo.js
+var React = __toESM(require_react());
+function useMemo(getValue, condition, shouldUpdate) {
+  var cacheRef = React.useRef({});
+  if (!("value" in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
+    cacheRef.current.value = getValue();
+    cacheRef.current.condition = condition;
+  }
+  return cacheRef.current.value;
+}
+
+export {
+  _arrayWithHoles,
+  _arrayLikeToArray,
+  _unsupportedIterableToArray,
+  _nonIterableRest,
+  _slicedToArray,
+  _objectWithoutProperties,
+  _objectSpread2,
+  canUseDom,
+  contains,
+  removeCSS,
+  updateCSS,
+  warning,
+  noteOnce,
+  warning_default,
+  useMemo
+};
+//# sourceMappingURL=chunk-KBMHTFOP.js.map

web/node_modules/.vite/deps/chunk-KNOBAKGH.js

@@ -0,0 +1,87 @@
+import {
+  require_react
+} from "./chunk-7ZNOTH45.js";
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js
+var require_use_sync_external_store_shim_development = __commonJS({
+  "node_modules/use-sync-external-store/cjs/use-sync-external-store-shim.development.js"(exports) {
+    "use strict";
+    (function() {
+      function is(x, y) {
+        return x === y && (0 !== x || 1 / x === 1 / y) || x !== x && y !== y;
+      }
+      function useSyncExternalStore$2(subscribe, getSnapshot) {
+        didWarnOld18Alpha || void 0 === React.startTransition || (didWarnOld18Alpha = true, console.error(
+          "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+        ));
+        var value = getSnapshot();
+        if (!didWarnUncachedGetSnapshot) {
+          var cachedValue = getSnapshot();
+          objectIs(value, cachedValue) || (console.error(
+            "The result of getSnapshot should be cached to avoid an infinite loop"
+          ), didWarnUncachedGetSnapshot = true);
+        }
+        cachedValue = useState({
+          inst: { value, getSnapshot }
+        });
+        var inst = cachedValue[0].inst, forceUpdate = cachedValue[1];
+        useLayoutEffect(
+          function() {
+            inst.value = value;
+            inst.getSnapshot = getSnapshot;
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+          },
+          [subscribe, value, getSnapshot]
+        );
+        useEffect(
+          function() {
+            checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            return subscribe(function() {
+              checkIfSnapshotChanged(inst) && forceUpdate({ inst });
+            });
+          },
+          [subscribe]
+        );
+        useDebugValue(value);
+        return value;
+      }
+      function checkIfSnapshotChanged(inst) {
+        var latestGetSnapshot = inst.getSnapshot;
+        inst = inst.value;
+        try {
+          var nextValue = latestGetSnapshot();
+          return !objectIs(inst, nextValue);
+        } catch (error) {
+          return true;
+        }
+      }
+      function useSyncExternalStore$1(subscribe, getSnapshot) {
+        return getSnapshot();
+      }
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+      var React = require_react(), objectIs = "function" === typeof Object.is ? Object.is : is, useState = React.useState, useEffect = React.useEffect, useLayoutEffect = React.useLayoutEffect, useDebugValue = React.useDebugValue, didWarnOld18Alpha = false, didWarnUncachedGetSnapshot = false, shim = "undefined" === typeof window || "undefined" === typeof window.document || "undefined" === typeof window.document.createElement ? useSyncExternalStore$1 : useSyncExternalStore$2;
+      exports.useSyncExternalStore = void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;
+      "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ && "function" === typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+    })();
+  }
+});
+
+// node_modules/use-sync-external-store/shim/index.js
+var require_shim = __commonJS({
+  "node_modules/use-sync-external-store/shim/index.js"(exports, module) {
+    "use strict";
+    if (false) {
+      module.exports = null;
+    } else {
+      module.exports = require_use_sync_external_store_shim_development();
+    }
+  }
+});
+
+export {
+  require_shim
+};
+//# sourceMappingURL=chunk-KNOBAKGH.js.map

web/node_modules/.vite/deps/chunk-KNOBAKGH.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../use-sync-external-store/cjs/use-sync-external-store-shim.development.js", "../../use-sync-external-store/shim/index.js"],
+  "sourcesContent": ["/**\n * @license React\n * use-sync-external-store-shim.development.js\n *\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n\"use strict\";\n\"production\" !== process.env.NODE_ENV &&\n  (function () {\n    function is(x, y) {\n      return (x === y && (0 !== x || 1 / x === 1 / y)) || (x !== x && y !== y);\n    }\n    function useSyncExternalStore$2(subscribe, getSnapshot) {\n      didWarnOld18Alpha ||\n        void 0 === React.startTransition ||\n        ((didWarnOld18Alpha = !0),\n        console.error(\n          \"You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release.\"\n        ));\n      var value = getSnapshot();\n      if (!didWarnUncachedGetSnapshot) {\n        var cachedValue = getSnapshot();\n        objectIs(value, cachedValue) ||\n          (console.error(\n            \"The result of getSnapshot should be cached to avoid an infinite loop\"\n          ),\n          (didWarnUncachedGetSnapshot = !0));\n      }\n      cachedValue = useState({\n        inst: { value: value, getSnapshot: getSnapshot }\n      });\n      var inst = cachedValue[0].inst,\n        forceUpdate = cachedValue[1];\n      useLayoutEffect(\n        function () {\n          inst.value = value;\n          inst.getSnapshot = getSnapshot;\n          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n        },\n        [subscribe, value, getSnapshot]\n      );\n      useEffect(\n        function () {\n          checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n          return subscribe(function () {\n            checkIfSnapshotChanged(inst) && forceUpdate({ inst: inst });\n          });\n        },\n        [subscribe]\n      );\n      useDebugValue(value);\n      return value;\n    }\n    function checkIfSnapshotChanged(inst) {\n      var latestGetSnapshot = inst.getSnapshot;\n      inst = inst.value;\n      try {\n        var nextValue = latestGetSnapshot();\n        return !objectIs(inst, nextValue);\n      } catch (error) {\n        return !0;\n      }\n    }\n    function useSyncExternalStore$1(subscribe, getSnapshot) {\n      return getSnapshot();\n    }\n    \"undefined\" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&\n      \"function\" ===\n        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart &&\n      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());\n    var React = require(\"react\"),\n      objectIs = \"function\" === typeof Object.is ? Object.is : is,\n      useState = React.useState,\n      useEffect = React.useEffect,\n      useLayoutEffect = React.useLayoutEffect,\n      useDebugValue = React.useDebugValue,\n      didWarnOld18Alpha = !1,\n      didWarnUncachedGetSnapshot = !1,\n      shim =\n        \"undefined\" === typeof window ||\n        \"undefined\" === typeof window.document ||\n        \"undefined\" === typeof window.document.createElement\n          ? useSyncExternalStore$1\n          : useSyncExternalStore$2;\n    exports.useSyncExternalStore =\n      void 0 !== React.useSyncExternalStore ? React.useSyncExternalStore : shim;\n    \"undefined\" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&\n      \"function\" ===\n        typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&\n      __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());\n  })();\n", "'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('../cjs/use-sync-external-store-shim.production.js');\n} else {\n  module.exports = require('../cjs/use-sync-external-store-shim.development.js');\n}\n"],
+  "mappings": ";;;;;;;;AAAA;AAAA;AAAA;AAWA,KACG,WAAY;AACX,eAAS,GAAG,GAAG,GAAG;AAChB,eAAQ,MAAM,MAAM,MAAM,KAAK,IAAI,MAAM,IAAI,MAAQ,MAAM,KAAK,MAAM;AAAA,MACxE;AACA,eAAS,uBAAuB,WAAW,aAAa;AACtD,6BACE,WAAW,MAAM,oBACf,oBAAoB,MACtB,QAAQ;AAAA,UACN;AAAA,QACF;AACF,YAAI,QAAQ,YAAY;AACxB,YAAI,CAAC,4BAA4B;AAC/B,cAAI,cAAc,YAAY;AAC9B,mBAAS,OAAO,WAAW,MACxB,QAAQ;AAAA,YACP;AAAA,UACF,GACC,6BAA6B;AAAA,QAClC;AACA,sBAAc,SAAS;AAAA,UACrB,MAAM,EAAE,OAAc,YAAyB;AAAA,QACjD,CAAC;AACD,YAAI,OAAO,YAAY,CAAC,EAAE,MACxB,cAAc,YAAY,CAAC;AAC7B;AAAA,UACE,WAAY;AACV,iBAAK,QAAQ;AACb,iBAAK,cAAc;AACnB,mCAAuB,IAAI,KAAK,YAAY,EAAE,KAAW,CAAC;AAAA,UAC5D;AAAA,UACA,CAAC,WAAW,OAAO,WAAW;AAAA,QAChC;AACA;AAAA,UACE,WAAY;AACV,mCAAuB,IAAI,KAAK,YAAY,EAAE,KAAW,CAAC;AAC1D,mBAAO,UAAU,WAAY;AAC3B,qCAAuB,IAAI,KAAK,YAAY,EAAE,KAAW,CAAC;AAAA,YAC5D,CAAC;AAAA,UACH;AAAA,UACA,CAAC,SAAS;AAAA,QACZ;AACA,sBAAc,KAAK;AACnB,eAAO;AAAA,MACT;AACA,eAAS,uBAAuB,MAAM;AACpC,YAAI,oBAAoB,KAAK;AAC7B,eAAO,KAAK;AACZ,YAAI;AACF,cAAI,YAAY,kBAAkB;AAClC,iBAAO,CAAC,SAAS,MAAM,SAAS;AAAA,QAClC,SAAS,OAAO;AACd,iBAAO;AAAA,QACT;AAAA,MACF;AACA,eAAS,uBAAuB,WAAW,aAAa;AACtD,eAAO,YAAY;AAAA,MACrB;AACA,sBAAgB,OAAO,kCACrB,eACE,OAAO,+BAA+B,+BACxC,+BAA+B,4BAA4B,MAAM,CAAC;AACpE,UAAI,QAAQ,iBACV,WAAW,eAAe,OAAO,OAAO,KAAK,OAAO,KAAK,IACzD,WAAW,MAAM,UACjB,YAAY,MAAM,WAClB,kBAAkB,MAAM,iBACxB,gBAAgB,MAAM,eACtB,oBAAoB,OACpB,6BAA6B,OAC7B,OACE,gBAAgB,OAAO,UACvB,gBAAgB,OAAO,OAAO,YAC9B,gBAAgB,OAAO,OAAO,SAAS,gBACnC,yBACA;AACR,cAAQ,uBACN,WAAW,MAAM,uBAAuB,MAAM,uBAAuB;AACvE,sBAAgB,OAAO,kCACrB,eACE,OAAO,+BAA+B,8BACxC,+BAA+B,2BAA2B,MAAM,CAAC;AAAA,IACrE,GAAG;AAAA;AAAA;;;AC9FL;AAAA;AAAA;AAEA,QAAI,OAAuC;AACzC,aAAO,UAAU;AAAA,IACnB,OAAO;AACL,aAAO,UAAU;AAAA,IACnB;AAAA;AAAA;",
+  "names": []
+}

web/node_modules/.vite/deps/chunk-KSAUAMBE.js

@@ -0,0 +1,288 @@
+import {
+  __commonJS
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/dayjs/dayjs.min.js
+var require_dayjs_min = __commonJS({
+  "node_modules/dayjs/dayjs.min.js"(exports, module) {
+    !(function(t, e) {
+      "object" == typeof exports && "undefined" != typeof module ? module.exports = e() : "function" == typeof define && define.amd ? define(e) : (t = "undefined" != typeof globalThis ? globalThis : t || self).dayjs = e();
+    })(exports, (function() {
+      "use strict";
+      var t = 1e3, e = 6e4, n = 36e5, r = "millisecond", i = "second", s = "minute", u = "hour", a = "day", o = "week", c = "month", f = "quarter", h = "year", d = "date", l = "Invalid Date", $ = /^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/, y = /\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g, M = { name: "en", weekdays: "Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"), months: "January_February_March_April_May_June_July_August_September_October_November_December".split("_"), ordinal: function(t2) {
+        var e2 = ["th", "st", "nd", "rd"], n2 = t2 % 100;
+        return "[" + t2 + (e2[(n2 - 20) % 10] || e2[n2] || e2[0]) + "]";
+      } }, m = function(t2, e2, n2) {
+        var r2 = String(t2);
+        return !r2 || r2.length >= e2 ? t2 : "" + Array(e2 + 1 - r2.length).join(n2) + t2;
+      }, v = { s: m, z: function(t2) {
+        var e2 = -t2.utcOffset(), n2 = Math.abs(e2), r2 = Math.floor(n2 / 60), i2 = n2 % 60;
+        return (e2 <= 0 ? "+" : "-") + m(r2, 2, "0") + ":" + m(i2, 2, "0");
+      }, m: function t2(e2, n2) {
+        if (e2.date() < n2.date()) return -t2(n2, e2);
+        var r2 = 12 * (n2.year() - e2.year()) + (n2.month() - e2.month()), i2 = e2.clone().add(r2, c), s2 = n2 - i2 < 0, u2 = e2.clone().add(r2 + (s2 ? -1 : 1), c);
+        return +(-(r2 + (n2 - i2) / (s2 ? i2 - u2 : u2 - i2)) || 0);
+      }, a: function(t2) {
+        return t2 < 0 ? Math.ceil(t2) || 0 : Math.floor(t2);
+      }, p: function(t2) {
+        return { M: c, y: h, w: o, d: a, D: d, h: u, m: s, s: i, ms: r, Q: f }[t2] || String(t2 || "").toLowerCase().replace(/s$/, "");
+      }, u: function(t2) {
+        return void 0 === t2;
+      } }, g = "en", D = {};
+      D[g] = M;
+      var p = "$isDayjsObject", S = function(t2) {
+        return t2 instanceof _ || !(!t2 || !t2[p]);
+      }, w = function t2(e2, n2, r2) {
+        var i2;
+        if (!e2) return g;
+        if ("string" == typeof e2) {
+          var s2 = e2.toLowerCase();
+          D[s2] && (i2 = s2), n2 && (D[s2] = n2, i2 = s2);
+          var u2 = e2.split("-");
+          if (!i2 && u2.length > 1) return t2(u2[0]);
+        } else {
+          var a2 = e2.name;
+          D[a2] = e2, i2 = a2;
+        }
+        return !r2 && i2 && (g = i2), i2 || !r2 && g;
+      }, O = function(t2, e2) {
+        if (S(t2)) return t2.clone();
+        var n2 = "object" == typeof e2 ? e2 : {};
+        return n2.date = t2, n2.args = arguments, new _(n2);
+      }, b = v;
+      b.l = w, b.i = S, b.w = function(t2, e2) {
+        return O(t2, { locale: e2.$L, utc: e2.$u, x: e2.$x, $offset: e2.$offset });
+      };
+      var _ = (function() {
+        function M2(t2) {
+          this.$L = w(t2.locale, null, true), this.parse(t2), this.$x = this.$x || t2.x || {}, this[p] = true;
+        }
+        var m2 = M2.prototype;
+        return m2.parse = function(t2) {
+          this.$d = (function(t3) {
+            var e2 = t3.date, n2 = t3.utc;
+            if (null === e2) return /* @__PURE__ */ new Date(NaN);
+            if (b.u(e2)) return /* @__PURE__ */ new Date();
+            if (e2 instanceof Date) return new Date(e2);
+            if ("string" == typeof e2 && !/Z$/i.test(e2)) {
+              var r2 = e2.match($);
+              if (r2) {
+                var i2 = r2[2] - 1 || 0, s2 = (r2[7] || "0").substring(0, 3);
+                return n2 ? new Date(Date.UTC(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2)) : new Date(r2[1], i2, r2[3] || 1, r2[4] || 0, r2[5] || 0, r2[6] || 0, s2);
+              }
+            }
+            return new Date(e2);
+          })(t2), this.init();
+        }, m2.init = function() {
+          var t2 = this.$d;
+          this.$y = t2.getFullYear(), this.$M = t2.getMonth(), this.$D = t2.getDate(), this.$W = t2.getDay(), this.$H = t2.getHours(), this.$m = t2.getMinutes(), this.$s = t2.getSeconds(), this.$ms = t2.getMilliseconds();
+        }, m2.$utils = function() {
+          return b;
+        }, m2.isValid = function() {
+          return !(this.$d.toString() === l);
+        }, m2.isSame = function(t2, e2) {
+          var n2 = O(t2);
+          return this.startOf(e2) <= n2 && n2 <= this.endOf(e2);
+        }, m2.isAfter = function(t2, e2) {
+          return O(t2) < this.startOf(e2);
+        }, m2.isBefore = function(t2, e2) {
+          return this.endOf(e2) < O(t2);
+        }, m2.$g = function(t2, e2, n2) {
+          return b.u(t2) ? this[e2] : this.set(n2, t2);
+        }, m2.unix = function() {
+          return Math.floor(this.valueOf() / 1e3);
+        }, m2.valueOf = function() {
+          return this.$d.getTime();
+        }, m2.startOf = function(t2, e2) {
+          var n2 = this, r2 = !!b.u(e2) || e2, f2 = b.p(t2), l2 = function(t3, e3) {
+            var i2 = b.w(n2.$u ? Date.UTC(n2.$y, e3, t3) : new Date(n2.$y, e3, t3), n2);
+            return r2 ? i2 : i2.endOf(a);
+          }, $2 = function(t3, e3) {
+            return b.w(n2.toDate()[t3].apply(n2.toDate("s"), (r2 ? [0, 0, 0, 0] : [23, 59, 59, 999]).slice(e3)), n2);
+          }, y2 = this.$W, M3 = this.$M, m3 = this.$D, v2 = "set" + (this.$u ? "UTC" : "");
+          switch (f2) {
+            case h:
+              return r2 ? l2(1, 0) : l2(31, 11);
+            case c:
+              return r2 ? l2(1, M3) : l2(0, M3 + 1);
+            case o:
+              var g2 = this.$locale().weekStart || 0, D2 = (y2 < g2 ? y2 + 7 : y2) - g2;
+              return l2(r2 ? m3 - D2 : m3 + (6 - D2), M3);
+            case a:
+            case d:
+              return $2(v2 + "Hours", 0);
+            case u:
+              return $2(v2 + "Minutes", 1);
+            case s:
+              return $2(v2 + "Seconds", 2);
+            case i:
+              return $2(v2 + "Milliseconds", 3);
+            default:
+              return this.clone();
+          }
+        }, m2.endOf = function(t2) {
+          return this.startOf(t2, false);
+        }, m2.$set = function(t2, e2) {
+          var n2, o2 = b.p(t2), f2 = "set" + (this.$u ? "UTC" : ""), l2 = (n2 = {}, n2[a] = f2 + "Date", n2[d] = f2 + "Date", n2[c] = f2 + "Month", n2[h] = f2 + "FullYear", n2[u] = f2 + "Hours", n2[s] = f2 + "Minutes", n2[i] = f2 + "Seconds", n2[r] = f2 + "Milliseconds", n2)[o2], $2 = o2 === a ? this.$D + (e2 - this.$W) : e2;
+          if (o2 === c || o2 === h) {
+            var y2 = this.clone().set(d, 1);
+            y2.$d[l2]($2), y2.init(), this.$d = y2.set(d, Math.min(this.$D, y2.daysInMonth())).$d;
+          } else l2 && this.$d[l2]($2);
+          return this.init(), this;
+        }, m2.set = function(t2, e2) {
+          return this.clone().$set(t2, e2);
+        }, m2.get = function(t2) {
+          return this[b.p(t2)]();
+        }, m2.add = function(r2, f2) {
+          var d2, l2 = this;
+          r2 = Number(r2);
+          var $2 = b.p(f2), y2 = function(t2) {
+            var e2 = O(l2);
+            return b.w(e2.date(e2.date() + Math.round(t2 * r2)), l2);
+          };
+          if ($2 === c) return this.set(c, this.$M + r2);
+          if ($2 === h) return this.set(h, this.$y + r2);
+          if ($2 === a) return y2(1);
+          if ($2 === o) return y2(7);
+          var M3 = (d2 = {}, d2[s] = e, d2[u] = n, d2[i] = t, d2)[$2] || 1, m3 = this.$d.getTime() + r2 * M3;
+          return b.w(m3, this);
+        }, m2.subtract = function(t2, e2) {
+          return this.add(-1 * t2, e2);
+        }, m2.format = function(t2) {
+          var e2 = this, n2 = this.$locale();
+          if (!this.isValid()) return n2.invalidDate || l;
+          var r2 = t2 || "YYYY-MM-DDTHH:mm:ssZ", i2 = b.z(this), s2 = this.$H, u2 = this.$m, a2 = this.$M, o2 = n2.weekdays, c2 = n2.months, f2 = n2.meridiem, h2 = function(t3, n3, i3, s3) {
+            return t3 && (t3[n3] || t3(e2, r2)) || i3[n3].slice(0, s3);
+          }, d2 = function(t3) {
+            return b.s(s2 % 12 || 12, t3, "0");
+          }, $2 = f2 || function(t3, e3, n3) {
+            var r3 = t3 < 12 ? "AM" : "PM";
+            return n3 ? r3.toLowerCase() : r3;
+          };
+          return r2.replace(y, (function(t3, r3) {
+            return r3 || (function(t4) {
+              switch (t4) {
+                case "YY":
+                  return String(e2.$y).slice(-2);
+                case "YYYY":
+                  return b.s(e2.$y, 4, "0");
+                case "M":
+                  return a2 + 1;
+                case "MM":
+                  return b.s(a2 + 1, 2, "0");
+                case "MMM":
+                  return h2(n2.monthsShort, a2, c2, 3);
+                case "MMMM":
+                  return h2(c2, a2);
+                case "D":
+                  return e2.$D;
+                case "DD":
+                  return b.s(e2.$D, 2, "0");
+                case "d":
+                  return String(e2.$W);
+                case "dd":
+                  return h2(n2.weekdaysMin, e2.$W, o2, 2);
+                case "ddd":
+                  return h2(n2.weekdaysShort, e2.$W, o2, 3);
+                case "dddd":
+                  return o2[e2.$W];
+                case "H":
+                  return String(s2);
+                case "HH":
+                  return b.s(s2, 2, "0");
+                case "h":
+                  return d2(1);
+                case "hh":
+                  return d2(2);
+                case "a":
+                  return $2(s2, u2, true);
+                case "A":
+                  return $2(s2, u2, false);
+                case "m":
+                  return String(u2);
+                case "mm":
+                  return b.s(u2, 2, "0");
+                case "s":
+                  return String(e2.$s);
+                case "ss":
+                  return b.s(e2.$s, 2, "0");
+                case "SSS":
+                  return b.s(e2.$ms, 3, "0");
+                case "Z":
+                  return i2;
+              }
+              return null;
+            })(t3) || i2.replace(":", "");
+          }));
+        }, m2.utcOffset = function() {
+          return 15 * -Math.round(this.$d.getTimezoneOffset() / 15);
+        }, m2.diff = function(r2, d2, l2) {
+          var $2, y2 = this, M3 = b.p(d2), m3 = O(r2), v2 = (m3.utcOffset() - this.utcOffset()) * e, g2 = this - m3, D2 = function() {
+            return b.m(y2, m3);
+          };
+          switch (M3) {
+            case h:
+              $2 = D2() / 12;
+              break;
+            case c:
+              $2 = D2();
+              break;
+            case f:
+              $2 = D2() / 3;
+              break;
+            case o:
+              $2 = (g2 - v2) / 6048e5;
+              break;
+            case a:
+              $2 = (g2 - v2) / 864e5;
+              break;
+            case u:
+              $2 = g2 / n;
+              break;
+            case s:
+              $2 = g2 / e;
+              break;
+            case i:
+              $2 = g2 / t;
+              break;
+            default:
+              $2 = g2;
+          }
+          return l2 ? $2 : b.a($2);
+        }, m2.daysInMonth = function() {
+          return this.endOf(c).$D;
+        }, m2.$locale = function() {
+          return D[this.$L];
+        }, m2.locale = function(t2, e2) {
+          if (!t2) return this.$L;
+          var n2 = this.clone(), r2 = w(t2, e2, true);
+          return r2 && (n2.$L = r2), n2;
+        }, m2.clone = function() {
+          return b.w(this.$d, this);
+        }, m2.toDate = function() {
+          return new Date(this.valueOf());
+        }, m2.toJSON = function() {
+          return this.isValid() ? this.toISOString() : null;
+        }, m2.toISOString = function() {
+          return this.$d.toISOString();
+        }, m2.toString = function() {
+          return this.$d.toUTCString();
+        }, M2;
+      })(), k = _.prototype;
+      return O.prototype = k, [["$ms", r], ["$s", i], ["$m", s], ["$H", u], ["$W", a], ["$M", c], ["$y", h], ["$D", d]].forEach((function(t2) {
+        k[t2[1]] = function(e2) {
+          return this.$g(e2, t2[0], t2[1]);
+        };
+      })), O.extend = function(t2, e2) {
+        return t2.$i || (t2(e2, _, O), t2.$i = true), O;
+      }, O.locale = w, O.isDayjs = S, O.unix = function(t2) {
+        return O(1e3 * t2);
+      }, O.en = D[g], O.Ls = D, O.p = {}, O;
+    }));
+  }
+});
+
+export {
+  require_dayjs_min
+};
+//# sourceMappingURL=chunk-KSAUAMBE.js.map

web/node_modules/.vite/deps/chunk-LSZRMDFG.js

@@ -0,0 +1,717 @@
+import {
+  KeyboardCode,
+  closestCorners,
+  getClientRect,
+  getFirstCollision,
+  getScrollableAncestors,
+  useDndContext,
+  useDraggable,
+  useDroppable
+} from "./chunk-6VAXZ5AU.js";
+import {
+  CSS,
+  isKeyboardEvent,
+  subtract,
+  useCombinedRefs,
+  useIsomorphicLayoutEffect,
+  useUniqueId
+} from "./chunk-3DUEC4BE.js";
+import {
+  require_react
+} from "./chunk-7ZNOTH45.js";
+import {
+  __toESM
+} from "./chunk-V4OQ3NZ2.js";
+
+// node_modules/@dnd-kit/sortable/dist/sortable.esm.js
+var import_react = __toESM(require_react());
+function arrayMove(array, from, to) {
+  const newArray = array.slice();
+  newArray.splice(to < 0 ? newArray.length + to : to, 0, newArray.splice(from, 1)[0]);
+  return newArray;
+}
+function arraySwap(array, from, to) {
+  const newArray = array.slice();
+  newArray[from] = array[to];
+  newArray[to] = array[from];
+  return newArray;
+}
+function getSortedRects(items, rects) {
+  return items.reduce((accumulator, id, index) => {
+    const rect = rects.get(id);
+    if (rect) {
+      accumulator[index] = rect;
+    }
+    return accumulator;
+  }, Array(items.length));
+}
+function isValidIndex(index) {
+  return index !== null && index >= 0;
+}
+function itemsEqual(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.length !== b.length) {
+    return false;
+  }
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function normalizeDisabled(disabled) {
+  if (typeof disabled === "boolean") {
+    return {
+      draggable: disabled,
+      droppable: disabled
+    };
+  }
+  return disabled;
+}
+var defaultScale = {
+  scaleX: 1,
+  scaleY: 1
+};
+var horizontalListSortingStrategy = (_ref) => {
+  var _rects$activeIndex;
+  let {
+    rects,
+    activeNodeRect: fallbackActiveRect,
+    activeIndex,
+    overIndex,
+    index
+  } = _ref;
+  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
+  if (!activeNodeRect) {
+    return null;
+  }
+  const itemGap = getItemGap(rects, index, activeIndex);
+  if (index === activeIndex) {
+    const newIndexRect = rects[overIndex];
+    if (!newIndexRect) {
+      return null;
+    }
+    return {
+      x: activeIndex < overIndex ? newIndexRect.left + newIndexRect.width - (activeNodeRect.left + activeNodeRect.width) : newIndexRect.left - activeNodeRect.left,
+      y: 0,
+      ...defaultScale
+    };
+  }
+  if (index > activeIndex && index <= overIndex) {
+    return {
+      x: -activeNodeRect.width - itemGap,
+      y: 0,
+      ...defaultScale
+    };
+  }
+  if (index < activeIndex && index >= overIndex) {
+    return {
+      x: activeNodeRect.width + itemGap,
+      y: 0,
+      ...defaultScale
+    };
+  }
+  return {
+    x: 0,
+    y: 0,
+    ...defaultScale
+  };
+};
+function getItemGap(rects, index, activeIndex) {
+  const currentRect = rects[index];
+  const previousRect = rects[index - 1];
+  const nextRect = rects[index + 1];
+  if (!currentRect || !previousRect && !nextRect) {
+    return 0;
+  }
+  if (activeIndex < index) {
+    return previousRect ? currentRect.left - (previousRect.left + previousRect.width) : nextRect.left - (currentRect.left + currentRect.width);
+  }
+  return nextRect ? nextRect.left - (currentRect.left + currentRect.width) : currentRect.left - (previousRect.left + previousRect.width);
+}
+var rectSortingStrategy = (_ref) => {
+  let {
+    rects,
+    activeIndex,
+    overIndex,
+    index
+  } = _ref;
+  const newRects = arrayMove(rects, overIndex, activeIndex);
+  const oldRect = rects[index];
+  const newRect = newRects[index];
+  if (!newRect || !oldRect) {
+    return null;
+  }
+  return {
+    x: newRect.left - oldRect.left,
+    y: newRect.top - oldRect.top,
+    scaleX: newRect.width / oldRect.width,
+    scaleY: newRect.height / oldRect.height
+  };
+};
+var rectSwappingStrategy = (_ref) => {
+  let {
+    activeIndex,
+    index,
+    rects,
+    overIndex
+  } = _ref;
+  let oldRect;
+  let newRect;
+  if (index === activeIndex) {
+    oldRect = rects[index];
+    newRect = rects[overIndex];
+  }
+  if (index === overIndex) {
+    oldRect = rects[index];
+    newRect = rects[activeIndex];
+  }
+  if (!newRect || !oldRect) {
+    return null;
+  }
+  return {
+    x: newRect.left - oldRect.left,
+    y: newRect.top - oldRect.top,
+    scaleX: newRect.width / oldRect.width,
+    scaleY: newRect.height / oldRect.height
+  };
+};
+var defaultScale$1 = {
+  scaleX: 1,
+  scaleY: 1
+};
+var verticalListSortingStrategy = (_ref) => {
+  var _rects$activeIndex;
+  let {
+    activeIndex,
+    activeNodeRect: fallbackActiveRect,
+    index,
+    rects,
+    overIndex
+  } = _ref;
+  const activeNodeRect = (_rects$activeIndex = rects[activeIndex]) != null ? _rects$activeIndex : fallbackActiveRect;
+  if (!activeNodeRect) {
+    return null;
+  }
+  if (index === activeIndex) {
+    const overIndexRect = rects[overIndex];
+    if (!overIndexRect) {
+      return null;
+    }
+    return {
+      x: 0,
+      y: activeIndex < overIndex ? overIndexRect.top + overIndexRect.height - (activeNodeRect.top + activeNodeRect.height) : overIndexRect.top - activeNodeRect.top,
+      ...defaultScale$1
+    };
+  }
+  const itemGap = getItemGap$1(rects, index, activeIndex);
+  if (index > activeIndex && index <= overIndex) {
+    return {
+      x: 0,
+      y: -activeNodeRect.height - itemGap,
+      ...defaultScale$1
+    };
+  }
+  if (index < activeIndex && index >= overIndex) {
+    return {
+      x: 0,
+      y: activeNodeRect.height + itemGap,
+      ...defaultScale$1
+    };
+  }
+  return {
+    x: 0,
+    y: 0,
+    ...defaultScale$1
+  };
+};
+function getItemGap$1(clientRects, index, activeIndex) {
+  const currentRect = clientRects[index];
+  const previousRect = clientRects[index - 1];
+  const nextRect = clientRects[index + 1];
+  if (!currentRect) {
+    return 0;
+  }
+  if (activeIndex < index) {
+    return previousRect ? currentRect.top - (previousRect.top + previousRect.height) : nextRect ? nextRect.top - (currentRect.top + currentRect.height) : 0;
+  }
+  return nextRect ? nextRect.top - (currentRect.top + currentRect.height) : previousRect ? currentRect.top - (previousRect.top + previousRect.height) : 0;
+}
+var ID_PREFIX = "Sortable";
+var Context = import_react.default.createContext({
+  activeIndex: -1,
+  containerId: ID_PREFIX,
+  disableTransforms: false,
+  items: [],
+  overIndex: -1,
+  useDragOverlay: false,
+  sortedRects: [],
+  strategy: rectSortingStrategy,
+  disabled: {
+    draggable: false,
+    droppable: false
+  }
+});
+function SortableContext(_ref) {
+  let {
+    children,
+    id,
+    items: userDefinedItems,
+    strategy = rectSortingStrategy,
+    disabled: disabledProp = false
+  } = _ref;
+  const {
+    active,
+    dragOverlay,
+    droppableRects,
+    over,
+    measureDroppableContainers
+  } = useDndContext();
+  const containerId = useUniqueId(ID_PREFIX, id);
+  const useDragOverlay = Boolean(dragOverlay.rect !== null);
+  const items = (0, import_react.useMemo)(() => userDefinedItems.map((item) => typeof item === "object" && "id" in item ? item.id : item), [userDefinedItems]);
+  const isDragging = active != null;
+  const activeIndex = active ? items.indexOf(active.id) : -1;
+  const overIndex = over ? items.indexOf(over.id) : -1;
+  const previousItemsRef = (0, import_react.useRef)(items);
+  const itemsHaveChanged = !itemsEqual(items, previousItemsRef.current);
+  const disableTransforms = overIndex !== -1 && activeIndex === -1 || itemsHaveChanged;
+  const disabled = normalizeDisabled(disabledProp);
+  useIsomorphicLayoutEffect(() => {
+    if (itemsHaveChanged && isDragging) {
+      measureDroppableContainers(items);
+    }
+  }, [itemsHaveChanged, items, isDragging, measureDroppableContainers]);
+  (0, import_react.useEffect)(() => {
+    previousItemsRef.current = items;
+  }, [items]);
+  const contextValue = (0, import_react.useMemo)(
+    () => ({
+      activeIndex,
+      containerId,
+      disabled,
+      disableTransforms,
+      items,
+      overIndex,
+      useDragOverlay,
+      sortedRects: getSortedRects(items, droppableRects),
+      strategy
+    }),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [activeIndex, containerId, disabled.draggable, disabled.droppable, disableTransforms, items, overIndex, droppableRects, useDragOverlay, strategy]
+  );
+  return import_react.default.createElement(Context.Provider, {
+    value: contextValue
+  }, children);
+}
+var defaultNewIndexGetter = (_ref) => {
+  let {
+    id,
+    items,
+    activeIndex,
+    overIndex
+  } = _ref;
+  return arrayMove(items, activeIndex, overIndex).indexOf(id);
+};
+var defaultAnimateLayoutChanges = (_ref2) => {
+  let {
+    containerId,
+    isSorting,
+    wasDragging,
+    index,
+    items,
+    newIndex,
+    previousItems,
+    previousContainerId,
+    transition
+  } = _ref2;
+  if (!transition || !wasDragging) {
+    return false;
+  }
+  if (previousItems !== items && index === newIndex) {
+    return false;
+  }
+  if (isSorting) {
+    return true;
+  }
+  return newIndex !== index && containerId === previousContainerId;
+};
+var defaultTransition = {
+  duration: 200,
+  easing: "ease"
+};
+var transitionProperty = "transform";
+var disabledTransition = CSS.Transition.toString({
+  property: transitionProperty,
+  duration: 0,
+  easing: "linear"
+});
+var defaultAttributes = {
+  roleDescription: "sortable"
+};
+function useDerivedTransform(_ref) {
+  let {
+    disabled,
+    index,
+    node,
+    rect
+  } = _ref;
+  const [derivedTransform, setDerivedtransform] = (0, import_react.useState)(null);
+  const previousIndex = (0, import_react.useRef)(index);
+  useIsomorphicLayoutEffect(() => {
+    if (!disabled && index !== previousIndex.current && node.current) {
+      const initial = rect.current;
+      if (initial) {
+        const current = getClientRect(node.current, {
+          ignoreTransform: true
+        });
+        const delta = {
+          x: initial.left - current.left,
+          y: initial.top - current.top,
+          scaleX: initial.width / current.width,
+          scaleY: initial.height / current.height
+        };
+        if (delta.x || delta.y) {
+          setDerivedtransform(delta);
+        }
+      }
+    }
+    if (index !== previousIndex.current) {
+      previousIndex.current = index;
+    }
+  }, [disabled, index, node, rect]);
+  (0, import_react.useEffect)(() => {
+    if (derivedTransform) {
+      setDerivedtransform(null);
+    }
+  }, [derivedTransform]);
+  return derivedTransform;
+}
+function useSortable(_ref) {
+  let {
+    animateLayoutChanges = defaultAnimateLayoutChanges,
+    attributes: userDefinedAttributes,
+    disabled: localDisabled,
+    data: customData,
+    getNewIndex = defaultNewIndexGetter,
+    id,
+    strategy: localStrategy,
+    resizeObserverConfig,
+    transition = defaultTransition
+  } = _ref;
+  const {
+    items,
+    containerId,
+    activeIndex,
+    disabled: globalDisabled,
+    disableTransforms,
+    sortedRects,
+    overIndex,
+    useDragOverlay,
+    strategy: globalStrategy
+  } = (0, import_react.useContext)(Context);
+  const disabled = normalizeLocalDisabled(localDisabled, globalDisabled);
+  const index = items.indexOf(id);
+  const data = (0, import_react.useMemo)(() => ({
+    sortable: {
+      containerId,
+      index,
+      items
+    },
+    ...customData
+  }), [containerId, customData, index, items]);
+  const itemsAfterCurrentSortable = (0, import_react.useMemo)(() => items.slice(items.indexOf(id)), [items, id]);
+  const {
+    rect,
+    node,
+    isOver,
+    setNodeRef: setDroppableNodeRef
+  } = useDroppable({
+    id,
+    data,
+    disabled: disabled.droppable,
+    resizeObserverConfig: {
+      updateMeasurementsFor: itemsAfterCurrentSortable,
+      ...resizeObserverConfig
+    }
+  });
+  const {
+    active,
+    activatorEvent,
+    activeNodeRect,
+    attributes,
+    setNodeRef: setDraggableNodeRef,
+    listeners,
+    isDragging,
+    over,
+    setActivatorNodeRef,
+    transform
+  } = useDraggable({
+    id,
+    data,
+    attributes: {
+      ...defaultAttributes,
+      ...userDefinedAttributes
+    },
+    disabled: disabled.draggable
+  });
+  const setNodeRef = useCombinedRefs(setDroppableNodeRef, setDraggableNodeRef);
+  const isSorting = Boolean(active);
+  const displaceItem = isSorting && !disableTransforms && isValidIndex(activeIndex) && isValidIndex(overIndex);
+  const shouldDisplaceDragSource = !useDragOverlay && isDragging;
+  const dragSourceDisplacement = shouldDisplaceDragSource && displaceItem ? transform : null;
+  const strategy = localStrategy != null ? localStrategy : globalStrategy;
+  const finalTransform = displaceItem ? dragSourceDisplacement != null ? dragSourceDisplacement : strategy({
+    rects: sortedRects,
+    activeNodeRect,
+    activeIndex,
+    overIndex,
+    index
+  }) : null;
+  const newIndex = isValidIndex(activeIndex) && isValidIndex(overIndex) ? getNewIndex({
+    id,
+    items,
+    activeIndex,
+    overIndex
+  }) : index;
+  const activeId = active == null ? void 0 : active.id;
+  const previous = (0, import_react.useRef)({
+    activeId,
+    items,
+    newIndex,
+    containerId
+  });
+  const itemsHaveChanged = items !== previous.current.items;
+  const shouldAnimateLayoutChanges = animateLayoutChanges({
+    active,
+    containerId,
+    isDragging,
+    isSorting,
+    id,
+    index,
+    items,
+    newIndex: previous.current.newIndex,
+    previousItems: previous.current.items,
+    previousContainerId: previous.current.containerId,
+    transition,
+    wasDragging: previous.current.activeId != null
+  });
+  const derivedTransform = useDerivedTransform({
+    disabled: !shouldAnimateLayoutChanges,
+    index,
+    node,
+    rect
+  });
+  (0, import_react.useEffect)(() => {
+    if (isSorting && previous.current.newIndex !== newIndex) {
+      previous.current.newIndex = newIndex;
+    }
+    if (containerId !== previous.current.containerId) {
+      previous.current.containerId = containerId;
+    }
+    if (items !== previous.current.items) {
+      previous.current.items = items;
+    }
+  }, [isSorting, newIndex, containerId, items]);
+  (0, import_react.useEffect)(() => {
+    if (activeId === previous.current.activeId) {
+      return;
+    }
+    if (activeId && !previous.current.activeId) {
+      previous.current.activeId = activeId;
+      return;
+    }
+    const timeoutId = setTimeout(() => {
+      previous.current.activeId = activeId;
+    }, 50);
+    return () => clearTimeout(timeoutId);
+  }, [activeId]);
+  return {
+    active,
+    activeIndex,
+    attributes,
+    data,
+    rect,
+    index,
+    newIndex,
+    items,
+    isOver,
+    isSorting,
+    isDragging,
+    listeners,
+    node,
+    overIndex,
+    over,
+    setNodeRef,
+    setActivatorNodeRef,
+    setDroppableNodeRef,
+    setDraggableNodeRef,
+    transform: derivedTransform != null ? derivedTransform : finalTransform,
+    transition: getTransition()
+  };
+  function getTransition() {
+    if (
+      // Temporarily disable transitions for a single frame to set up derived transforms
+      derivedTransform || // Or to prevent items jumping to back to their "new" position when items change
+      itemsHaveChanged && previous.current.newIndex === index
+    ) {
+      return disabledTransition;
+    }
+    if (shouldDisplaceDragSource && !isKeyboardEvent(activatorEvent) || !transition) {
+      return void 0;
+    }
+    if (isSorting || shouldAnimateLayoutChanges) {
+      return CSS.Transition.toString({
+        ...transition,
+        property: transitionProperty
+      });
+    }
+    return void 0;
+  }
+}
+function normalizeLocalDisabled(localDisabled, globalDisabled) {
+  var _localDisabled$dragga, _localDisabled$droppa;
+  if (typeof localDisabled === "boolean") {
+    return {
+      draggable: localDisabled,
+      // Backwards compatibility
+      droppable: false
+    };
+  }
+  return {
+    draggable: (_localDisabled$dragga = localDisabled == null ? void 0 : localDisabled.draggable) != null ? _localDisabled$dragga : globalDisabled.draggable,
+    droppable: (_localDisabled$droppa = localDisabled == null ? void 0 : localDisabled.droppable) != null ? _localDisabled$droppa : globalDisabled.droppable
+  };
+}
+function hasSortableData(entry) {
+  if (!entry) {
+    return false;
+  }
+  const data = entry.data.current;
+  if (data && "sortable" in data && typeof data.sortable === "object" && "containerId" in data.sortable && "items" in data.sortable && "index" in data.sortable) {
+    return true;
+  }
+  return false;
+}
+var directions = [KeyboardCode.Down, KeyboardCode.Right, KeyboardCode.Up, KeyboardCode.Left];
+var sortableKeyboardCoordinates = (event, _ref) => {
+  let {
+    context: {
+      active,
+      collisionRect,
+      droppableRects,
+      droppableContainers,
+      over,
+      scrollableAncestors
+    }
+  } = _ref;
+  if (directions.includes(event.code)) {
+    event.preventDefault();
+    if (!active || !collisionRect) {
+      return;
+    }
+    const filteredContainers = [];
+    droppableContainers.getEnabled().forEach((entry) => {
+      if (!entry || entry != null && entry.disabled) {
+        return;
+      }
+      const rect = droppableRects.get(entry.id);
+      if (!rect) {
+        return;
+      }
+      switch (event.code) {
+        case KeyboardCode.Down:
+          if (collisionRect.top < rect.top) {
+            filteredContainers.push(entry);
+          }
+          break;
+        case KeyboardCode.Up:
+          if (collisionRect.top > rect.top) {
+            filteredContainers.push(entry);
+          }
+          break;
+        case KeyboardCode.Left:
+          if (collisionRect.left > rect.left) {
+            filteredContainers.push(entry);
+          }
+          break;
+        case KeyboardCode.Right:
+          if (collisionRect.left < rect.left) {
+            filteredContainers.push(entry);
+          }
+          break;
+      }
+    });
+    const collisions = closestCorners({
+      active,
+      collisionRect,
+      droppableRects,
+      droppableContainers: filteredContainers,
+      pointerCoordinates: null
+    });
+    let closestId = getFirstCollision(collisions, "id");
+    if (closestId === (over == null ? void 0 : over.id) && collisions.length > 1) {
+      closestId = collisions[1].id;
+    }
+    if (closestId != null) {
+      const activeDroppable = droppableContainers.get(active.id);
+      const newDroppable = droppableContainers.get(closestId);
+      const newRect = newDroppable ? droppableRects.get(newDroppable.id) : null;
+      const newNode = newDroppable == null ? void 0 : newDroppable.node.current;
+      if (newNode && newRect && activeDroppable && newDroppable) {
+        const newScrollAncestors = getScrollableAncestors(newNode);
+        const hasDifferentScrollAncestors = newScrollAncestors.some((element, index) => scrollableAncestors[index] !== element);
+        const hasSameContainer = isSameContainer(activeDroppable, newDroppable);
+        const isAfterActive = isAfter(activeDroppable, newDroppable);
+        const offset = hasDifferentScrollAncestors || !hasSameContainer ? {
+          x: 0,
+          y: 0
+        } : {
+          x: isAfterActive ? collisionRect.width - newRect.width : 0,
+          y: isAfterActive ? collisionRect.height - newRect.height : 0
+        };
+        const rectCoordinates = {
+          x: newRect.left,
+          y: newRect.top
+        };
+        const newCoordinates = offset.x && offset.y ? rectCoordinates : subtract(rectCoordinates, offset);
+        return newCoordinates;
+      }
+    }
+  }
+  return void 0;
+};
+function isSameContainer(a, b) {
+  if (!hasSortableData(a) || !hasSortableData(b)) {
+    return false;
+  }
+  return a.data.current.sortable.containerId === b.data.current.sortable.containerId;
+}
+function isAfter(a, b) {
+  if (!hasSortableData(a) || !hasSortableData(b)) {
+    return false;
+  }
+  if (!isSameContainer(a, b)) {
+    return false;
+  }
+  return a.data.current.sortable.index < b.data.current.sortable.index;
+}
+
+export {
+  arrayMove,
+  arraySwap,
+  horizontalListSortingStrategy,
+  rectSortingStrategy,
+  rectSwappingStrategy,
+  verticalListSortingStrategy,
+  SortableContext,
+  defaultNewIndexGetter,
+  defaultAnimateLayoutChanges,
+  useSortable,
+  hasSortableData,
+  sortableKeyboardCoordinates
+};
+//# sourceMappingURL=chunk-LSZRMDFG.js.map