admin felület fejlesztése garázs, előfizeztési csomagok

2026-06-25 01:58:04 +00:00
parent 80a5d67f79
commit 52011606ff
334 changed files with 46636 additions and 1606 deletions
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@7.7.9/node_modules/@vue/devtools-kit
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@7.7.9/node_modules/@vue/devtools-kit
@@ -0,0 +1 @@
+../../../devtools-kit@7.7.9
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/dist/index.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/dist/index.js
@@ -0,0 +1,2 @@
+import { addCustomCommand, addCustomTab, onDevToolsClientConnected, onDevToolsConnected, removeCustomCommand, setupDevToolsPlugin, setupDevToolsPlugin as setupDevtoolsPlugin } from "@vue/devtools-kit";
+export { addCustomCommand, addCustomTab, onDevToolsClientConnected, onDevToolsConnected, removeCustomCommand, setupDevToolsPlugin, setupDevtoolsPlugin };
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/node_modules/@vue/devtools-kit
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/node_modules/@vue/devtools-kit
@@ -0,0 +1 @@
+../../../devtools-kit@8.1.3
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-api@8.1.3/package.json
@@ -0,0 +1,34 @@
+{
+  "name": "@vue/devtools-api",
+  "type": "module",
+  "version": "8.1.3",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/devtools-api",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "unpkg": "dist/vue-devtools-api.global.js",
+  "jsdelivr": "dist/vue-devtools-api.global.js",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@vue/devtools-kit": "^8.1.3"
+  },
+  "scripts": {
+    "build": "tsdown --clean",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/dist/index.cjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/dist/index.cjs
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/@vue/devtools-shared
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/@vue/devtools-shared
@@ -0,0 +1 @@
+../../../devtools-shared@7.7.9
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/hookable
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/hookable
@@ -0,0 +1 @@
+../../../hookable@5.5.3
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/perfect-debounce
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/node_modules/perfect-debounce
@@ -0,0 +1 @@
+../../../perfect-debounce@1.0.0
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@7.7.9/package.json
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/dist/index.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/dist/index.js
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/@vue/devtools-shared
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/@vue/devtools-shared
@@ -0,0 +1 @@
+../../../devtools-shared@8.1.3
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/hookable
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/hookable
@@ -0,0 +1 @@
+../../../hookable@5.5.3
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/perfect-debounce
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/node_modules/perfect-debounce
@@ -0,0 +1 @@
+../../../perfect-debounce@2.1.0
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-kit@8.1.3/package.json
@@ -0,0 +1,43 @@
+{
+  "name": "@vue/devtools-kit",
+  "type": "module",
+  "version": "8.1.3",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/devtools-kit",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./types.d.ts",
+  "files": [
+    "**.d.ts",
+    "dist"
+  ],
+  "dependencies": {
+    "birpc": "^2.6.1",
+    "hookable": "^5.5.3",
+    "perfect-debounce": "^2.0.0",
+    "@vue/devtools-shared": "^8.1.3"
+  },
+  "devDependencies": {
+    "@types/speakingurl": "^13.0.6",
+    "speakingurl": "^14.0.1",
+    "superjson": "^2.2.2",
+    "vue": "^3.5.22",
+    "vue-router": "^4.6.0"
+  },
+  "scripts": {
+    "build": "tsdown --clean",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@7.7.9/dist/index.cjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@7.7.9/dist/index.cjs
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@7.7.9/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@7.7.9/package.json
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@8.1.3/dist/index.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@8.1.3/dist/index.js
@@ -0,0 +1,239 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region src/constants.ts
+const VIEW_MODE_STORAGE_KEY = "__vue-devtools-view-mode__";
+const VITE_PLUGIN_DETECTED_STORAGE_KEY = "__vue-devtools-vite-plugin-detected__";
+const VITE_PLUGIN_CLIENT_URL_STORAGE_KEY = "__vue-devtools-vite-plugin-client-url__";
+const BROADCAST_CHANNEL_NAME = "__vue-devtools-broadcast-channel__";
+//#endregion
+//#region src/env.ts
+const isBrowser = typeof navigator !== "undefined";
+const target = typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : typeof global !== "undefined" ? global : {};
+const isInChromePanel = typeof target.chrome !== "undefined" && !!target.chrome.devtools;
+const isInIframe = isBrowser && target.self !== target.top;
+const isInElectron = typeof navigator !== "undefined" && navigator.userAgent?.toLowerCase().includes("electron");
+const isNuxtApp = typeof window !== "undefined" && !!window.__NUXT__;
+const isInSeparateWindow = !isInIframe && !isInChromePanel && !isInElectron;
+//#endregion
+//#region src/general.ts
+var import_rfdc = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = rfdc;
+	function copyBuffer(cur) {
+		if (cur instanceof Buffer) return Buffer.from(cur);
+		return new cur.constructor(cur.buffer.slice(), cur.byteOffset, cur.length);
+	}
+	function rfdc(opts) {
+		opts = opts || {};
+		if (opts.circles) return rfdcCircles(opts);
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler of opts.constructorHandlers) constructorHandlers.set(handler[0], handler[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else a2[k] = fn(cur);
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = clone(cur);
+			}
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else o2[k] = cloneProto(cur);
+			}
+			return o2;
+		}
+	}
+	function rfdcCircles(opts) {
+		const refs = [];
+		const refsNew = [];
+		const constructorHandlers = /* @__PURE__ */ new Map();
+		constructorHandlers.set(Date, (o) => new Date(o));
+		constructorHandlers.set(Map, (o, fn) => new Map(cloneArray(Array.from(o), fn)));
+		constructorHandlers.set(Set, (o, fn) => new Set(cloneArray(Array.from(o), fn)));
+		if (opts.constructorHandlers) for (const handler of opts.constructorHandlers) constructorHandlers.set(handler[0], handler[1]);
+		let handler = null;
+		return opts.proto ? cloneProto : clone;
+		function cloneArray(a, fn) {
+			const keys = Object.keys(a);
+			const a2 = new Array(keys.length);
+			for (let i = 0; i < keys.length; i++) {
+				const k = keys[i];
+				const cur = a[k];
+				if (typeof cur !== "object" || cur === null) a2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) a2[k] = handler(cur, fn);
+				else if (ArrayBuffer.isView(cur)) a2[k] = copyBuffer(cur);
+				else {
+					const index = refs.indexOf(cur);
+					if (index !== -1) a2[k] = refsNew[index];
+					else a2[k] = fn(cur);
+				}
+			}
+			return a2;
+		}
+		function clone(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, clone);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, clone);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				if (Object.hasOwnProperty.call(o, k) === false) continue;
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, clone);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = clone(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+		function cloneProto(o) {
+			if (typeof o !== "object" || o === null) return o;
+			if (Array.isArray(o)) return cloneArray(o, cloneProto);
+			if (o.constructor !== Object && (handler = constructorHandlers.get(o.constructor))) return handler(o, cloneProto);
+			const o2 = {};
+			refs.push(o);
+			refsNew.push(o2);
+			for (const k in o) {
+				const cur = o[k];
+				if (typeof cur !== "object" || cur === null) o2[k] = cur;
+				else if (cur.constructor !== Object && (handler = constructorHandlers.get(cur.constructor))) o2[k] = handler(cur, cloneProto);
+				else if (ArrayBuffer.isView(cur)) o2[k] = copyBuffer(cur);
+				else {
+					const i = refs.indexOf(cur);
+					if (i !== -1) o2[k] = refsNew[i];
+					else o2[k] = cloneProto(cur);
+				}
+			}
+			refs.pop();
+			refsNew.pop();
+			return o2;
+		}
+	}
+})))(), 1);
+function NOOP() {}
+const isNumeric = (str) => `${+str}` === str;
+const isMacOS = () => navigator?.platform ? navigator?.platform.toLowerCase().includes("mac") : /Macintosh/.test(navigator.userAgent);
+const classifyRE = /(?:^|[-_/])(\w)/g;
+const camelizeRE = /-(\w)/g;
+const kebabizeRE = /([a-z0-9])([A-Z])/g;
+function toUpper(_, c) {
+	return c ? c.toUpperCase() : "";
+}
+function classify(str) {
+	return str && `${str}`.replace(classifyRE, toUpper);
+}
+function camelize(str) {
+	return str && str.replace(camelizeRE, toUpper);
+}
+function kebabize(str) {
+	return str && str.replace(kebabizeRE, (_, lowerCaseCharacter, upperCaseLetter) => {
+		return `${lowerCaseCharacter}-${upperCaseLetter}`;
+	}).toLowerCase();
+}
+function basename(filename, ext) {
+	let normalizedFilename = filename.replace(/^[a-z]:/i, "").replace(/\\/g, "/");
+	if (normalizedFilename.endsWith(`index${ext}`)) normalizedFilename = normalizedFilename.replace(`/index${ext}`, ext);
+	const lastSlashIndex = normalizedFilename.lastIndexOf("/");
+	const baseNameWithExt = normalizedFilename.substring(lastSlashIndex + 1);
+	if (ext) {
+		const extIndex = baseNameWithExt.lastIndexOf(ext);
+		return baseNameWithExt.substring(0, extIndex);
+	}
+	return "";
+}
+function sortByKey(state) {
+	return state && state.slice().sort((a, b) => {
+		if (a.key < b.key) return -1;
+		if (a.key > b.key) return 1;
+		return 0;
+	});
+}
+const HTTP_URL_RE = /^https?:\/\//;
+/**
+* Check a string is start with `/` or a valid http url
+*/
+function isUrlString(str) {
+	return str.startsWith("/") || HTTP_URL_RE.test(str);
+}
+/**
+* @copyright [rfdc](https://github.com/davidmarkclements/rfdc)
+* @description A really fast deep clone alternative
+*/
+const deepClone = (0, import_rfdc.default)({ circles: true });
+function randomStr() {
+	return Math.random().toString(36).slice(2);
+}
+function isObject(value) {
+	return typeof value === "object" && !Array.isArray(value) && value !== null;
+}
+function isArray(value) {
+	return Array.isArray(value);
+}
+function isSet(value) {
+	return value instanceof Set;
+}
+function isMap(value) {
+	return value instanceof Map;
+}
+//#endregion
+export { BROADCAST_CHANNEL_NAME, NOOP, VIEW_MODE_STORAGE_KEY, VITE_PLUGIN_CLIENT_URL_STORAGE_KEY, VITE_PLUGIN_DETECTED_STORAGE_KEY, basename, camelize, classify, deepClone, isArray, isBrowser, isInChromePanel, isInElectron, isInIframe, isInSeparateWindow, isMacOS, isMap, isNumeric, isNuxtApp, isObject, isSet, isUrlString, kebabize, randomStr, sortByKey, target };
--- a/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@8.1.3/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/@vue/devtools-shared@8.1.3/package.json
@@ -0,0 +1,32 @@
+{
+  "name": "@vue/devtools-shared",
+  "type": "module",
+  "version": "8.1.3",
+  "author": "webfansplz",
+  "license": "MIT",
+  "repository": {
+    "directory": "packages/shared",
+    "type": "git",
+    "url": "git+https://github.com/vuejs/devtools.git"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^24.7.2",
+    "rfdc": "^1.4.1"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepare:type": "tsdown --dts-only",
+    "stub": "tsdown --watch --onSuccess 'tsdown --dts-only'"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/.nitro/hookable@5.5.3/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/hookable@5.5.3/dist/index.mjs
@@ -0,0 +1,290 @@
+function flatHooks(configHooks, hooks = {}, parentName) {
+  for (const key in configHooks) {
+    const subHook = configHooks[key];
+    const name = parentName ? `${parentName}:${key}` : key;
+    if (typeof subHook === "object" && subHook !== null) {
+      flatHooks(subHook, hooks, name);
+    } else if (typeof subHook === "function") {
+      hooks[name] = subHook;
+    }
+  }
+  return hooks;
+}
+function mergeHooks(...hooks) {
+  const finalHooks = {};
+  for (const hook of hooks) {
+    const flatenHook = flatHooks(hook);
+    for (const key in flatenHook) {
+      if (finalHooks[key]) {
+        finalHooks[key].push(flatenHook[key]);
+      } else {
+        finalHooks[key] = [flatenHook[key]];
+      }
+    }
+  }
+  for (const key in finalHooks) {
+    if (finalHooks[key].length > 1) {
+      const array = finalHooks[key];
+      finalHooks[key] = (...arguments_) => serial(array, (function_) => function_(...arguments_));
+    } else {
+      finalHooks[key] = finalHooks[key][0];
+    }
+  }
+  return finalHooks;
+}
+function serial(tasks, function_) {
+  return tasks.reduce(
+    (promise, task) => promise.then(() => function_(task)),
+    Promise.resolve()
+  );
+}
+const defaultTask = { run: (function_) => function_() };
+const _createTask = () => defaultTask;
+const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
+function serialTaskCaller(hooks, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
+    Promise.resolve()
+  );
+}
+function parallelTaskCaller(hooks, args) {
+  const name = args.shift();
+  const task = createTask(name);
+  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
+}
+function serialCaller(hooks, arguments_) {
+  return hooks.reduce(
+    (promise, hookFunction) => promise.then(() => hookFunction(...arguments_ || [])),
+    Promise.resolve()
+  );
+}
+function parallelCaller(hooks, args) {
+  return Promise.all(hooks.map((hook) => hook(...args || [])));
+}
+function callEachWith(callbacks, arg0) {
+  for (const callback of [...callbacks]) {
+    callback(arg0);
+  }
+}
+
+class Hookable {
+  constructor() {
+    this._hooks = {};
+    this._before = void 0;
+    this._after = void 0;
+    this._deprecatedMessages = void 0;
+    this._deprecatedHooks = {};
+    this.hook = this.hook.bind(this);
+    this.callHook = this.callHook.bind(this);
+    this.callHookWith = this.callHookWith.bind(this);
+  }
+  hook(name, function_, options = {}) {
+    if (!name || typeof function_ !== "function") {
+      return () => {
+      };
+    }
+    const originalName = name;
+    let dep;
+    while (this._deprecatedHooks[name]) {
+      dep = this._deprecatedHooks[name];
+      name = dep.to;
+    }
+    if (dep && !options.allowDeprecated) {
+      let message = dep.message;
+      if (!message) {
+        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
+      }
+      if (!this._deprecatedMessages) {
+        this._deprecatedMessages = /* @__PURE__ */ new Set();
+      }
+      if (!this._deprecatedMessages.has(message)) {
+        console.warn(message);
+        this._deprecatedMessages.add(message);
+      }
+    }
+    if (!function_.name) {
+      try {
+        Object.defineProperty(function_, "name", {
+          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
+          configurable: true
+        });
+      } catch {
+      }
+    }
+    this._hooks[name] = this._hooks[name] || [];
+    this._hooks[name].push(function_);
+    return () => {
+      if (function_) {
+        this.removeHook(name, function_);
+        function_ = void 0;
+      }
+    };
+  }
+  hookOnce(name, function_) {
+    let _unreg;
+    let _function = (...arguments_) => {
+      if (typeof _unreg === "function") {
+        _unreg();
+      }
+      _unreg = void 0;
+      _function = void 0;
+      return function_(...arguments_);
+    };
+    _unreg = this.hook(name, _function);
+    return _unreg;
+  }
+  removeHook(name, function_) {
+    if (this._hooks[name]) {
+      const index = this._hooks[name].indexOf(function_);
+      if (index !== -1) {
+        this._hooks[name].splice(index, 1);
+      }
+      if (this._hooks[name].length === 0) {
+        delete this._hooks[name];
+      }
+    }
+  }
+  deprecateHook(name, deprecated) {
+    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
+    const _hooks = this._hooks[name] || [];
+    delete this._hooks[name];
+    for (const hook of _hooks) {
+      this.hook(name, hook);
+    }
+  }
+  deprecateHooks(deprecatedHooks) {
+    Object.assign(this._deprecatedHooks, deprecatedHooks);
+    for (const name in deprecatedHooks) {
+      this.deprecateHook(name, deprecatedHooks[name]);
+    }
+  }
+  addHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    const removeFns = Object.keys(hooks).map(
+      (key) => this.hook(key, hooks[key])
+    );
+    return () => {
+      for (const unreg of removeFns.splice(0, removeFns.length)) {
+        unreg();
+      }
+    };
+  }
+  removeHooks(configHooks) {
+    const hooks = flatHooks(configHooks);
+    for (const key in hooks) {
+      this.removeHook(key, hooks[key]);
+    }
+  }
+  removeAllHooks() {
+    for (const key in this._hooks) {
+      delete this._hooks[key];
+    }
+  }
+  callHook(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(serialTaskCaller, name, ...arguments_);
+  }
+  callHookParallel(name, ...arguments_) {
+    arguments_.unshift(name);
+    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
+  }
+  callHookWith(caller, name, ...arguments_) {
+    const event = this._before || this._after ? { name, args: arguments_, context: {} } : void 0;
+    if (this._before) {
+      callEachWith(this._before, event);
+    }
+    const result = caller(
+      name in this._hooks ? [...this._hooks[name]] : [],
+      arguments_
+    );
+    if (result instanceof Promise) {
+      return result.finally(() => {
+        if (this._after && event) {
+          callEachWith(this._after, event);
+        }
+      });
+    }
+    if (this._after && event) {
+      callEachWith(this._after, event);
+    }
+    return result;
+  }
+  beforeEach(function_) {
+    this._before = this._before || [];
+    this._before.push(function_);
+    return () => {
+      if (this._before !== void 0) {
+        const index = this._before.indexOf(function_);
+        if (index !== -1) {
+          this._before.splice(index, 1);
+        }
+      }
+    };
+  }
+  afterEach(function_) {
+    this._after = this._after || [];
+    this._after.push(function_);
+    return () => {
+      if (this._after !== void 0) {
+        const index = this._after.indexOf(function_);
+        if (index !== -1) {
+          this._after.splice(index, 1);
+        }
+      }
+    };
+  }
+}
+function createHooks() {
+  return new Hookable();
+}
+
+const isBrowser = typeof window !== "undefined";
+function createDebugger(hooks, _options = {}) {
+  const options = {
+    inspect: isBrowser,
+    group: isBrowser,
+    filter: () => true,
+    ..._options
+  };
+  const _filter = options.filter;
+  const filter = typeof _filter === "string" ? (name) => name.startsWith(_filter) : _filter;
+  const _tag = options.tag ? `[${options.tag}] ` : "";
+  const logPrefix = (event) => _tag + event.name + "".padEnd(event._id, "\0");
+  const _idCtr = {};
+  const unsubscribeBefore = hooks.beforeEach((event) => {
+    if (filter !== void 0 && !filter(event.name)) {
+      return;
+    }
+    _idCtr[event.name] = _idCtr[event.name] || 0;
+    event._id = _idCtr[event.name]++;
+    console.time(logPrefix(event));
+  });
+  const unsubscribeAfter = hooks.afterEach((event) => {
+    if (filter !== void 0 && !filter(event.name)) {
+      return;
+    }
+    if (options.group) {
+      console.groupCollapsed(event.name);
+    }
+    if (options.inspect) {
+      console.timeLog(logPrefix(event), event.args);
+    } else {
+      console.timeEnd(logPrefix(event));
+    }
+    if (options.group) {
+      console.groupEnd();
+    }
+    _idCtr[event.name]--;
+  });
+  return {
+    /** Stop debugging and remove listeners */
+    close: () => {
+      unsubscribeBefore();
+      unsubscribeAfter();
+    }
+  };
+}
+
+export { Hookable, createDebugger, createHooks, flatHooks, mergeHooks, parallelCaller, serial, serialCaller };
--- a/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@1.0.0/dist/index.cjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@1.0.0/dist/index.cjs
--- a/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@1.0.0/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@1.0.0/package.json
--- a/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@2.1.0/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@2.1.0/dist/index.mjs
@@ -0,0 +1,89 @@
+//#region src/index.ts
+const DEBOUNCE_DEFAULTS = { trailing: true };
+/**
+Debounce functions
+@param fn - Promise-returning/async function to debounce.
+@param wait - Milliseconds to wait before calling `fn`. Default value is 25ms
+@returns A function that delays calling `fn` until after `wait` milliseconds have elapsed since the last time it was called.
+@example
+```
+import { debounce } from 'perfect-debounce';
+const expensiveCall = async input => input;
+const debouncedFn = debounce(expensiveCall, 200);
+for (const number of [1, 2, 3]) {
+console.log(await debouncedFn(number));
+}
+//=> 1
+//=> 2
+//=> 3
+```
+*/
+function debounce(fn, wait = 25, options = {}) {
+	options = {
+		...DEBOUNCE_DEFAULTS,
+		...options
+	};
+	if (!Number.isFinite(wait)) throw new TypeError("Expected `wait` to be a finite number");
+	let leadingValue;
+	let timeout;
+	let resolveList = [];
+	let currentPromise;
+	let trailingArgs;
+	const applyFn = (_this, args) => {
+		currentPromise = _applyPromised(fn, _this, args);
+		currentPromise.finally(() => {
+			currentPromise = null;
+			if (options.trailing && trailingArgs && !timeout) {
+				const promise = applyFn(_this, trailingArgs);
+				trailingArgs = null;
+				return promise;
+			}
+		});
+		return currentPromise;
+	};
+	const debounced = function(...args) {
+		if (options.trailing) trailingArgs = args;
+		if (currentPromise) return currentPromise;
+		return new Promise((resolve) => {
+			const shouldCallNow = !timeout && options.leading;
+			clearTimeout(timeout);
+			timeout = setTimeout(() => {
+				timeout = null;
+				const promise = options.leading ? leadingValue : applyFn(this, args);
+				trailingArgs = null;
+				for (const _resolve of resolveList) _resolve(promise);
+				resolveList = [];
+			}, wait);
+			if (shouldCallNow) {
+				leadingValue = applyFn(this, args);
+				resolve(leadingValue);
+			} else resolveList.push(resolve);
+		});
+	};
+	const _clearTimeout = (timer) => {
+		if (timer) {
+			clearTimeout(timer);
+			timeout = null;
+		}
+	};
+	debounced.isPending = () => !!timeout;
+	debounced.cancel = () => {
+		_clearTimeout(timeout);
+		resolveList = [];
+		trailingArgs = null;
+	};
+	debounced.flush = () => {
+		_clearTimeout(timeout);
+		if (!trailingArgs || currentPromise) return;
+		const args = trailingArgs;
+		trailingArgs = null;
+		return applyFn(this, args);
+	};
+	return debounced;
+}
+async function _applyPromised(fn, _this, args) {
+	return await fn.apply(_this, args);
+}
+
+//#endregion
+export { debounce };
--- a/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@2.1.0/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/perfect-debounce@2.1.0/package.json
@@ -0,0 +1,41 @@
+{
+  "name": "perfect-debounce",
+  "version": "2.1.0",
+  "description": "",
+  "repository": "unjs/perfect-debounce",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier --check src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "@vitest/coverage-v8": "^4.0.17",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "eslint-config-unjs": "^0.6.2",
+    "in-range": "^3.0.0",
+    "obuild": "^0.4.18",
+    "prettier": "^3.8.1",
+    "time-span": "^5.1.0",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "packageManager": "pnpm@10.28.1"
+}
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/dist/devtools-EWN81iOl.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/dist/devtools-EWN81iOl.mjs
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/dist/vue-router.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/dist/vue-router.mjs
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/node_modules/@vue/devtools-api
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/node_modules/@vue/devtools-api
@@ -0,0 +1 @@
+../../../@vue/devtools-api@6.6.4
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/package.json
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/vue-router.node.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@4.6.4/vue-router.node.mjs
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/devtools-DCoWQoU_.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/devtools-DCoWQoU_.js
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/useApi-s_02lHjl.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/useApi-s_02lHjl.js
@@ -0,0 +1,181 @@
+/*!
+* vue-router v5.1.0
+* (c) 2026 Eduardo San Martin Morote
+* @license MIT
+*/
+import { inject } from "vue";
+//#region src/utils/env.ts
+const isBrowser = typeof document !== "undefined";
+//#endregion
+//#region src/utils/index.ts
+/**
+* Identity function that returns the value as is.
+*
+* @param v - the value to return
+*
+* @internal
+*/
+const identityFn = (v) => v;
+/**
+* Allows differentiating lazy components from functional components and vue-class-component
+* @internal
+*
+* @param component
+*/
+function isRouteComponent(component) {
+	return typeof component === "object" || "displayName" in component || "props" in component || "__vccOpts" in component;
+}
+function isESModule(obj) {
+	return obj.__esModule || obj[Symbol.toStringTag] === "Module" || obj.default && isRouteComponent(obj.default);
+}
+const assign = Object.assign;
+function applyToParams(fn, params) {
+	const newParams = {};
+	for (const key in params) {
+		const value = params[key];
+		newParams[key] = isArray(value) ? value.map(fn) : fn(value);
+	}
+	return newParams;
+}
+const noop = () => {};
+/**
+* Typesafe alternative to Array.isArray
+* https://github.com/microsoft/TypeScript/pull/48228
+*
+* @internal
+*/
+const isArray = Array.isArray;
+function mergeOptions(defaults, partialOptions) {
+	const options = {};
+	for (const key in defaults) options[key] = key in partialOptions ? partialOptions[key] : defaults[key];
+	return options;
+}
+//#endregion
+//#region src/errors.ts
+const NavigationFailureSymbol = Symbol(process.env.NODE_ENV !== "production" ? "navigation failure" : "");
+/**
+* Enumeration with all possible types for navigation failures. Can be passed to
+* {@link isNavigationFailure} to check for specific failures.
+*/
+let NavigationFailureType = /* @__PURE__ */ function(NavigationFailureType) {
+	/**
+	* An aborted navigation is a navigation that failed because a navigation
+	* guard returned `false` or called `next(false)`
+	*/
+	NavigationFailureType[NavigationFailureType["aborted"] = 4] = "aborted";
+	/**
+	* A cancelled navigation is a navigation that failed because a more recent
+	* navigation finished started (not necessarily finished).
+	*/
+	NavigationFailureType[NavigationFailureType["cancelled"] = 8] = "cancelled";
+	/**
+	* A duplicated navigation is a navigation that failed because it was
+	* initiated while already being at the exact same location.
+	*/
+	NavigationFailureType[NavigationFailureType["duplicated"] = 16] = "duplicated";
+	return NavigationFailureType;
+}({});
+const ErrorTypeMessages = {
+	[1]({ location, currentLocation }) {
+		return `No match for\n ${JSON.stringify(location)}${currentLocation ? "\nwhile being at\n" + JSON.stringify(currentLocation) : ""}`;
+	},
+	[2]({ from, to }) {
+		return `Redirected from "${from.fullPath}" to "${stringifyRoute(to)}" via a navigation guard.`;
+	},
+	[4]({ from, to }) {
+		return `Navigation aborted from "${from.fullPath}" to "${to.fullPath}" via a navigation guard.`;
+	},
+	[8]({ from, to }) {
+		return `Navigation cancelled from "${from.fullPath}" to "${to.fullPath}" with a new navigation.`;
+	},
+	[16]({ from, to: _to }) {
+		return `Avoided redundant navigation to current location: "${from.fullPath}".`;
+	}
+};
+/**
+* Creates a typed NavigationFailure object.
+* @internal
+* @param type - NavigationFailureType
+* @param params - { from, to }
+*/
+function createRouterError(type, params) {
+	if (process.env.NODE_ENV !== "production" || false) return assign(new Error(ErrorTypeMessages[type](params)), {
+		type,
+		[NavigationFailureSymbol]: true
+	}, params);
+	else return assign(/* @__PURE__ */ new Error(), {
+		type,
+		[NavigationFailureSymbol]: true
+	}, params);
+}
+function isNavigationFailure(error, type) {
+	return error instanceof Error && NavigationFailureSymbol in error && (type == null || !!(error.type & type));
+}
+const propertiesToLog = [
+	"params",
+	"query",
+	"hash"
+];
+function stringifyRoute(to) {
+	if (typeof to === "string") return to;
+	if (to.path != null) return to.path;
+	const location = {};
+	for (const key of propertiesToLog) if (key in to) location[key] = to[key];
+	return JSON.stringify(location, null, 2);
+}
+//#endregion
+//#region src/injectionSymbols.ts
+/**
+* RouteRecord being rendered by the closest ancestor Router View. Used for
+* `onBeforeRouteUpdate` and `onBeforeRouteLeave`. rvlm stands for Router View
+* Location Matched
+*
+* @internal
+*/
+const matchedRouteKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location matched" : "");
+/**
+* Allows overriding the router view depth to control which component in
+* `matched` is rendered. rvd stands for Router View Depth
+*
+* @internal
+*/
+const viewDepthKey = Symbol(process.env.NODE_ENV !== "production" ? "router view depth" : "");
+/**
+* Allows overriding the router instance returned by `useRouter` in tests. r
+* stands for router
+*
+* @internal
+*/
+const routerKey = Symbol(process.env.NODE_ENV !== "production" ? "router" : "");
+/**
+* Allows overriding the current route returned by `useRoute` in tests. rl
+* stands for route location
+*
+* @internal
+*/
+const routeLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "route location" : "");
+/**
+* Allows overriding the current route used by router-view. Internally this is
+* used when the `route` prop is passed.
+*
+* @internal
+*/
+const routerViewLocationKey = Symbol(process.env.NODE_ENV !== "production" ? "router view location" : "");
+//#endregion
+//#region src/useApi.ts
+/**
+* Returns the router instance. Equivalent to using `$router` inside
+* templates.
+*/
+function useRouter() {
+	return inject(routerKey);
+}
+/**
+* Returns the current route location. Equivalent to using `$route` inside
+* templates.
+*/
+function useRoute(_name) {
+	return inject(routeLocationKey);
+}
+//#endregion
+export { mergeOptions as _, routerKey as a, NavigationFailureType as c, applyToParams as d, assign as f, isRouteComponent as g, isESModule as h, routeLocationKey as i, createRouterError as l, isArray as m, useRouter as n, routerViewLocationKey as o, identityFn as p, matchedRouteKey as r, viewDepthKey as s, useRoute as t, isNavigationFailure as u, noop as v, isBrowser as y };
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/vue-router.js
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/dist/vue-router.js
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/node_modules/@vue/devtools-api
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/node_modules/@vue/devtools-api
@@ -0,0 +1 @@
+../../../@vue/devtools-api@8.1.3
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/package.json
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/package.json
@@ -0,0 +1,226 @@
+{
+  "name": "vue-router",
+  "version": "5.1.0",
+  "homepage": "https://router.vuejs.org",
+  "bugs": {
+    "url": "https://github.com/vuejs/router/issues"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Eduardo San Martin Morote",
+    "email": "posva13@gmail.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/vuejs/router.git"
+  },
+  "funding": "https://github.com/sponsors/posva",
+  "files": [
+    "dist",
+    "index.cjs",
+    "README.md",
+    "route.schema.json",
+    "vue-router-auto-resolver.d.mts",
+    "vue-router-auto-routes.d.mts",
+    "vue-router-auto.d.ts",
+    "vue-router.node.mjs",
+    "vetur/attributes.json",
+    "vetur/tags.json"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "index.cjs",
+  "module": "dist/vue-router.js",
+  "types": "dist/vue-router.d.ts",
+  "typesVersions": {
+    "*": {
+      "vite": [
+        "./dist/unplugin/vite.d.mts"
+      ],
+      "unplugin": [
+        "./dist/unplugin/index.d.mts"
+      ],
+      "unplugin/*": [
+        "./dist/unplugin/*.d.mts"
+      ],
+      "volar/*": [
+        "./dist/volar/*.d.cts"
+      ]
+    }
+  },
+  "unpkg": "dist/vue-router.global.js",
+  "jsdelivr": "dist/vue-router.global.js",
+  "exports": {
+    ".": {
+      "types": "./dist/vue-router.d.ts",
+      "node": {
+        "import": {
+          "production": "./vue-router.node.mjs",
+          "development": "./vue-router.node.mjs",
+          "default": "./vue-router.node.mjs"
+        },
+        "require": {
+          "production": "./dist/vue-router.prod.cjs",
+          "development": "./dist/vue-router.cjs",
+          "default": "./dist/vue-router.prod.cjs"
+        }
+      },
+      "import": "./dist/vue-router.js",
+      "require": "./index.cjs"
+    },
+    "./vetur/*": "./vetur/*",
+    "./package.json": "./package.json",
+    "./experimental": {
+      "types": "./dist/experimental/index.d.ts",
+      "import": "./dist/experimental/index.js"
+    },
+    "./experimental/pinia-colada": {
+      "types": "./dist/experimental/pinia-colada.d.ts",
+      "import": "./dist/experimental/pinia-colada.js"
+    },
+    "./auto-resolver": {
+      "types": "./vue-router-auto-resolver.d.mts"
+    },
+    "./auto-routes": {
+      "types": "./vue-router-auto-routes.d.mts"
+    },
+    "./auto": {
+      "types": "./vue-router-auto.d.ts",
+      "node": {
+        "import": {
+          "production": "./vue-router.node.mjs",
+          "development": "./vue-router.node.mjs",
+          "default": "./vue-router.node.mjs"
+        },
+        "require": {
+          "production": "./dist/vue-router.prod.cjs",
+          "development": "./dist/vue-router.cjs",
+          "default": "./dist/vue-router.prod.cjs"
+        }
+      },
+      "import": "./dist/vue-router.js",
+      "require": "./index.cjs"
+    },
+    "./vite": {
+      "types": "./dist/unplugin/vite.d.mts",
+      "import": "./dist/unplugin/vite.mjs",
+      "require": "./dist/unplugin/vite.cjs"
+    },
+    "./unplugin": {
+      "types": "./dist/unplugin/index.d.mts",
+      "import": "./dist/unplugin/index.mjs",
+      "require": "./dist/unplugin/index.cjs"
+    },
+    "./unplugin/*": "./dist/unplugin/*",
+    "./volar/sfc-route-blocks": {
+      "types": "./dist/volar/sfc-route-blocks.d.cts",
+      "default": "./dist/volar/sfc-route-blocks.cjs"
+    },
+    "./volar/sfc-typed-router": {
+      "types": "./dist/volar/sfc-typed-router.d.cts",
+      "default": "./dist/volar/sfc-typed-router.cjs"
+    },
+    "./dist/*": "./dist/*"
+  },
+  "dependencies": {
+    "@babel/generator": "^8.0.0-rc.4",
+    "@vue-macros/common": "^3.1.1",
+    "@vue/devtools-api": "^8.1.2",
+    "ast-walker-scope": "^0.9.0",
+    "chokidar": "^5.0.0",
+    "json5": "^2.2.3",
+    "local-pkg": "^1.1.2",
+    "magic-string": "^0.30.21",
+    "mlly": "^1.8.2",
+    "muggle-string": "^0.4.1",
+    "pathe": "^2.0.3",
+    "picomatch": "^4.0.3",
+    "scule": "^1.3.0",
+    "tinyglobby": "^0.2.16",
+    "unplugin": "^3.0.0",
+    "unplugin-utils": "^0.3.1",
+    "yaml": "^2.9.0"
+  },
+  "devDependencies": {
+    "@babel/types": "^8.0.0-rc.4",
+    "@pinia/colada": "^1.3.1",
+    "@playwright/test": "^1.59.1",
+    "@rollup/plugin-commonjs": "^28.0.9",
+    "@rollup/plugin-node-resolve": "^16.0.3",
+    "@rollup/plugin-replace": "^6.0.3",
+    "@rollup/plugin-terser": "^0.4.4",
+    "@standard-schema/spec": "^1.1.0",
+    "@types/babel__generator": "^7.27.0",
+    "@types/nightwatch": "^2.3.32",
+    "@types/picomatch": "^4.0.2",
+    "@typescript/native-preview": "7.0.0-dev.20260106.1",
+    "@vitejs/plugin-vue": "^6.0.6",
+    "@vue/compiler-sfc": "^3.5.34",
+    "@vue/language-core": "^3.2.1",
+    "@vue/server-renderer": "^3.5.34",
+    "@vue/test-utils": "^2.4.10",
+    "browserstack-local": "^1.5.13",
+    "chromedriver": "^148.0.3",
+    "connect-history-api-fallback": "^2.0.0",
+    "dotenv": "^17.4.2",
+    "faked-promise": "^2.2.2",
+    "geckodriver": "^6.1.0",
+    "happy-dom": "^20.9.0",
+    "nightwatch": "^3.15.0",
+    "nightwatch-helpers": "^1.2.0",
+    "pinia": "^3.0.4",
+    "rimraf": "^6.1.3",
+    "rollup": "^4.57.1",
+    "rollup-plugin-typescript2": "^0.36.0",
+    "tsdown": "^0.22.0",
+    "tsup": "^8.5.1",
+    "valibot": "^1.4.1",
+    "vite": "^8.0.13",
+    "vue": "^3.5.34",
+    "zod": "^4.4.3"
+  },
+  "peerDependencies": {
+    "@pinia/colada": ">=0.21.2",
+    "@vue/compiler-sfc": "^3.5.34",
+    "pinia": "^3.0.4",
+    "vite": "^7.0.0 || ^8.0.0",
+    "vue": "^3.5.34"
+  },
+  "peerDependenciesMeta": {
+    "@vue/compiler-sfc": {
+      "optional": true
+    },
+    "pinia": {
+      "optional": true
+    },
+    "@pinia/colada": {
+      "optional": true
+    },
+    "vite": {
+      "optional": true
+    }
+  },
+  "vetur": {
+    "tags": "vetur/tags.json",
+    "attributes": "vetur/attributes.json"
+  },
+  "scripts": {
+    "dev": "vitest --ui",
+    "build": "tsdown",
+    "build:old": "rimraf dist && rollup -c rollup.config.mjs",
+    "build:playground": "vue-tsc --noEmit && vite build --config playground/vite.config.ts",
+    "build:e2e": "vue-tsc --noEmit && vite build --config e2e/vite.config.mjs",
+    "build:size": "pnpm run build && rollup -c size-checks/rollup.config.mjs",
+    "dev:e2e": "vite --config e2e/vite.config.mjs",
+    "test:types": "tsc --build tsconfig.json ./test-dts/tsconfig.experimental.json",
+    "test:unit": "vitest --coverage run",
+    "test": "pnpm run build && pnpm run '/^(unit|test:types)$/' && pnpm run '/^test:(e2e|e2e:hmr)$/'",
+    "test:e2e": "pnpm run test:e2e:headless",
+    "test:e2e:hmr": "pnpm exec playwright test",
+    "test:e2e:headless": "node e2e/runner.mjs --env chrome-headless",
+    "test:e2e:native": "node e2e/runner.mjs --env chrome",
+    "test:e2e:ci": "node e2e/runner.mjs --env chrome-headless --retries 2",
+    "test:e2e:bs": "node e2e/runner.mjs --local -e android5 --tag browserstack",
+    "test:e2e:bs-test": "node e2e/runner.mjs --local --env browserstack.local_chrome --tag browserstack"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/vue-router.node.mjs
+++ b/frontend_admin/.output/server/node_modules/.nitro/vue-router@5.1.0/vue-router.node.mjs
@@ -0,0 +1,2 @@
+global.__VUE_PROD_DEVTOOLS__ = false
+export * from './dist/vue-router.js'
--- a/frontend_admin/.output/server/node_modules/@intlify/core-base/dist/core-base.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/core-base/dist/core-base.mjs
--- a/frontend_admin/.output/server/node_modules/@intlify/core-base/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/core-base/package.json
@@ -0,0 +1,78 @@
+{
+  "name": "@intlify/core-base",
+  "version": "11.4.2",
+  "description": "@intlify/core-base",
+  "keywords": [
+    "core",
+    "fundamental",
+    "i18n",
+    "internationalization",
+    "intlify"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n/tree/master/packages/core-base#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/core-base.mjs",
+  "unpkg": "dist/core-base.global.js",
+  "jsdelivr": "dist/core-base.global.js",
+  "types": "dist/core-base.d.ts",
+  "dependencies": {
+    "@intlify/devtools-types": "11.4.2",
+    "@intlify/message-compiler": "11.4.2",
+    "@intlify/shared": "11.4.2"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyCoreBase",
+    "formats": [
+      "mjs",
+      "browser",
+      "cjs",
+      "global"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core-base.d.ts",
+      "import": "./dist/core-base.mjs",
+      "browser": "./dist/core-base.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/core-base.prod.cjs",
+          "development": "./dist/core-base.mjs",
+          "default": "./dist/core-base.prod.cjs"
+        },
+        "require": {
+          "production": "./dist/core-base.prod.cjs",
+          "development": "./dist/core-base.cjs",
+          "default": "./dist/core-base.prod.cjs"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}
--- a/frontend_admin/.output/server/node_modules/@intlify/core/dist/core.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/core/dist/core.mjs
@@ -0,0 +1,31 @@
+/*!
+  * core v11.4.2
+  * (c) 2026 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+import { registerMessageCompiler, compile, registerMessageResolver, resolveValue, registerLocaleFallbacker, fallbackWithLocaleChain } from '@intlify/core-base';
+export * from '@intlify/core-base';
+import { getGlobalThis } from '@intlify/shared';
+
+/**
+ * This is only called in esm-bundler builds.
+ * istanbul-ignore-next
+ */
+function initFeatureFlags() {
+    if (typeof __INTLIFY_PROD_DEVTOOLS__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_PROD_DEVTOOLS__ = false;
+    }
+    if (typeof __INTLIFY_DROP_MESSAGE_COMPILER__ !== 'boolean') {
+        getGlobalThis().__INTLIFY_DROP_MESSAGE_COMPILER__ = false;
+    }
+}
+
+{
+    initFeatureFlags();
+}
+// register message compiler at @intlify/core
+registerMessageCompiler(compile);
+// register message resolver at @intlify/core
+registerMessageResolver(resolveValue);
+// register fallback locale at @intlify/core
+registerLocaleFallbacker(fallbackWithLocaleChain);
--- a/frontend_admin/.output/server/node_modules/@intlify/core/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/core/package.json
@@ -0,0 +1,82 @@
+{
+  "name": "@intlify/core",
+  "version": "11.4.2",
+  "description": "@intlify/core",
+  "keywords": [
+    "core",
+    "fundamental",
+    "i18n",
+    "internationalization",
+    "intlify"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n/tree/master/packages/core#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n.git",
+    "directory": "packages/core"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/core.mjs",
+  "unpkg": "dist/core.global.js",
+  "jsdelivr": "dist/core.global.js",
+  "types": "dist/core.d.ts",
+  "dependencies": {
+    "@intlify/core-base": "11.4.2",
+    "@intlify/shared": "11.4.2"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyCore",
+    "formats": [
+      "mjs",
+      "mjs-node",
+      "mjs-runtime",
+      "mjs-node-runtime",
+      "browser",
+      "browser-runtime",
+      "cjs",
+      "global",
+      "global-runtime"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core.d.ts",
+      "import": "./dist/core.mjs",
+      "browser": "./dist/core.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/core.prod.node.mjs",
+          "development": "./dist/core.node.mjs",
+          "default": "./dist/core.prod.node.mjs"
+        },
+        "require": {
+          "production": "./dist/core.prod.cjs",
+          "development": "./dist/core.cjs",
+          "default": "./dist/core.prod.cjs"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": true
+}
--- a/frontend_admin/.output/server/node_modules/@intlify/h3/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/h3/dist/index.mjs
@@ -0,0 +1,65 @@
+import { createCoreContext, parseTranslateArgs, translate, NOT_REOSLVED } from '@intlify/core';
+import { getHeaderLocale } from '@intlify/utils/h3';
+export * from '@intlify/utils/h3';
+
+/**
+ * @author kazuya kawaguchi (a.k.a. kazupon)
+ * @license MIT
+ */
+function defineI18nMiddleware(options) {
+  const i18n = createCoreContext(options);
+  const orgLocale = i18n.locale;
+  let staticLocaleDetector = null;
+  if (typeof orgLocale === "string") {
+    console.warn(
+      `defineI18nMiddleware 'locale' option is static ${orgLocale} locale! you should specify dynamic locale detector function.`
+    );
+    staticLocaleDetector = () => orgLocale;
+  }
+  const getLocaleDetector = (event, i18n2) => {
+    return typeof orgLocale === "function" ? orgLocale.bind(null, event, i18n2) : staticLocaleDetector == null ? detectLocaleFromAcceptLanguageHeader.bind(null, event) : staticLocaleDetector.bind(null, event, i18n2);
+  };
+  return {
+    onRequest(event) {
+      event.context._i18nLocale = getLocaleDetector(event, i18n);
+      i18n.locale = event.context._i18nLocale;
+      event.context.i18n = i18n;
+    },
+    onAfterResponse(event) {
+      i18n.locale = orgLocale;
+      delete event.context.i18n;
+    }
+  };
+}
+const detectLocaleFromAcceptLanguageHeader = (event) => getHeaderLocale(event).toString();
+async function useTranslation(event) {
+  if (event.context.i18n == null) {
+    throw new Error(
+      "middleware not initialized, please setup `onRequest` and `onAfterResponse` options of `createApp` with the middleware obtained with `defineI18nMiddleware`"
+    );
+  }
+  const localeDetector = event.context._i18nLocale;
+  let locale;
+  if (localeDetector.constructor.name === "AsyncFunction") {
+    locale = await localeDetector(event);
+    event.context.i18n.locale = locale;
+  }
+  function translate$1(key, ...args) {
+    const [_, options] = parseTranslateArgs(key, ...args);
+    const [arg2] = args;
+    const result = Reflect.apply(translate, null, [
+      event.context.i18n,
+      key,
+      arg2,
+      {
+        // bind to request locale
+        locale,
+        ...options
+      }
+    ]);
+    return NOT_REOSLVED === result ? key : result;
+  }
+  return translate$1;
+}
+
+export { defineI18nMiddleware, detectLocaleFromAcceptLanguageHeader, useTranslation };
--- a/frontend_admin/.output/server/node_modules/@intlify/h3/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/h3/package.json
@@ -0,0 +1,122 @@
+{
+  "name": "@intlify/h3",
+  "description": "Internationalization middleware & utilities for h3",
+  "version": "0.7.4",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/kazupon",
+  "bugs": {
+    "url": "https://github.com/intlify/h3/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/h3.git"
+  },
+  "keywords": [
+    "i18n",
+    "h3",
+    "internationalization",
+    "intlify",
+    "utilities",
+    "middleware"
+  ],
+  "homepage": "https://github.com/intlify/h3#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 20"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "types": "dist/index.d.ts",
+  "dependencies": {
+    "@intlify/core": "^11.1.12",
+    "@intlify/utils": "^0.13.0"
+  },
+  "devDependencies": {
+    "@eslint/compat": "^1.4.1",
+    "@eslint/markdown": "^7.5.0",
+    "@kazupon/eslint-config": "^0.38.0",
+    "@kazupon/prettier-config": "^0.1.1",
+    "@types/node": "^24.9.2",
+    "@types/supertest": "^6.0.3",
+    "@typescript/native-preview": "7.0.0-dev.20251025.1",
+    "@vitest/coverage-v8": "^4.0.6",
+    "@vitest/eslint-plugin": "^1.4.0",
+    "bumpp": "^10.3.1",
+    "eslint": "^9.39.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-jsdoc": "^61.1.11",
+    "eslint-plugin-jsonc": "^2.21.0",
+    "eslint-plugin-markdown-preferences": "^0.36.2",
+    "eslint-plugin-module-interop": "^0.3.1",
+    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-regexp": "^2.10.0",
+    "eslint-plugin-unicorn": "^62.0.0",
+    "eslint-plugin-unused-imports": "^4.3.0",
+    "eslint-plugin-yml": "^1.19.0",
+    "gh-changelogen": "^0.2.8",
+    "h3": "^1.15.4",
+    "knip": "^5.66.4",
+    "lint-staged": "^16.2.6",
+    "prettier": "^3.6.2",
+    "supertest": "^7.1.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.46.2",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.0.6"
+  },
+  "prettier": "@kazupon/prettier-config",
+  "lint-staged": {
+    "*.ts?(x)": [
+      "prettier --parser=typescript --write",
+      "eslint --fix"
+    ],
+    "*.{js,mjs,cjs}": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.{json,jsonc,json5,md,yml,yaml}": [
+      "prettier --write"
+    ]
+  },
+  "scripts": {
+    "build": "unbuild",
+    "changelog": "gh-changelogen --repo=intlify/h3",
+    "dev:eslint": "pnpx @eslint/config-inspector --config eslint.config.ts",
+    "fix": "pnpm run --color \"/^fix:/\"",
+    "fix:eslint": "eslint . --fix",
+    "fix:knip": "knip --fix --no-exit-code",
+    "fix:prettier": "prettier . --write --experimental-cli",
+    "lint": "pnpm run --color \"/^lint:/\"",
+    "lint:eslint": "eslint . --cache",
+    "lint:knip": "knip",
+    "lint:prettier": "prettier . --check --experimental-cli",
+    "lint:typecheck": "tsgo --noEmit --diagnostics",
+    "play:basic": "pnpx tsx ./playground/basic/index.ts",
+    "release": "bumpp --commit \"release: v%s\" --push --tag",
+    "test": "pnpm run test:unit",
+    "test:coverage": "pnpm test --reporter verbose --coverage",
+    "test:unit": "vitest run --typecheck"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/@intlify/message-compiler/dist/message-compiler.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/message-compiler/dist/message-compiler.mjs
--- a/frontend_admin/.output/server/node_modules/@intlify/message-compiler/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/message-compiler/package.json
@@ -0,0 +1,79 @@
+{
+  "name": "@intlify/message-compiler",
+  "version": "11.4.2",
+  "description": "@intlify/message-compiler",
+  "keywords": [
+    "compiler",
+    "i18n",
+    "internationalization",
+    "intlify",
+    "message-format"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n/tree/master/packages/message-compiler#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n.git",
+    "directory": "packages/message-compiler"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/message-compiler.mjs",
+  "unpkg": "dist/message-compiler.global.js",
+  "jsdelivr": "dist/message-compiler.global.js",
+  "types": "dist/message-compiler.d.ts",
+  "dependencies": {
+    "source-map-js": "^1.0.2",
+    "@intlify/shared": "11.4.2"
+  },
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyMessageCompiler",
+    "formats": [
+      "mjs",
+      "mjs-node",
+      "browser",
+      "cjs",
+      "global"
+    ],
+    "enableFullBundleForEsmBrowser": true
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/message-compiler.d.ts",
+      "import": "./dist/message-compiler.mjs",
+      "browser": "./dist/message-compiler.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/message-compiler.node.mjs",
+          "development": "./dist/message-compiler.node.mjs",
+          "default": "./dist/message-compiler.node.mjs"
+        },
+        "require": {
+          "production": "./dist/message-compiler.prod.cjs",
+          "development": "./dist/message-compiler.cjs",
+          "default": "./dist/message-compiler.prod.cjs"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}
--- a/frontend_admin/.output/server/node_modules/@intlify/shared/dist/shared.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/shared/dist/shared.mjs
@@ -0,0 +1,281 @@
+/*!
+  * shared v11.4.2
+  * (c) 2026 kazuya kawaguchi
+  * Released under the MIT License.
+  */
+function warn(msg, err) {
+    if (typeof console !== 'undefined') {
+        console.warn(`[intlify] ` + msg);
+        /* istanbul ignore if */
+        if (err) {
+            console.warn(err.stack);
+        }
+    }
+}
+const hasWarned = {};
+function warnOnce(msg) {
+    if (!hasWarned[msg]) {
+        hasWarned[msg] = true;
+        warn(msg);
+    }
+}
+
+/**
+ * Original Utilities
+ * written by kazuya kawaguchi
+ */
+const inBrowser = typeof window !== 'undefined';
+let mark;
+let measure;
+if ((process.env.NODE_ENV !== 'production')) {
+    const perf = inBrowser && window.performance;
+    if (perf &&
+        perf.mark &&
+        perf.measure &&
+        perf.clearMarks &&
+        // @ts-ignore browser compat
+        perf.clearMeasures) {
+        mark = (tag) => {
+            perf.mark(tag);
+        };
+        measure = (name, startTag, endTag) => {
+            perf.measure(name, startTag, endTag);
+            perf.clearMarks(startTag);
+            perf.clearMarks(endTag);
+        };
+    }
+}
+const RE_ARGS = /\{([0-9a-zA-Z]+)\}/g;
+/* eslint-disable */
+function format(message, ...args) {
+    if (args.length === 1 && isObject(args[0])) {
+        args = args[0];
+    }
+    if (!args || !args.hasOwnProperty) {
+        args = {};
+    }
+    return message.replace(RE_ARGS, (match, identifier) => {
+        return args.hasOwnProperty(identifier) ? args[identifier] : '';
+    });
+}
+const makeSymbol = (name, shareable = false) => !shareable ? Symbol(name) : Symbol.for(name);
+const generateFormatCacheKey = (locale, key, source) => friendlyJSONstringify({ l: locale, k: key, s: source });
+const friendlyJSONstringify = (json) => JSON.stringify(json)
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029')
+    .replace(/\u0027/g, '\\u0027');
+const isNumber = (val) => typeof val === 'number' && isFinite(val);
+const isDate = (val) => toTypeString(val) === '[object Date]';
+const isRegExp = (val) => toTypeString(val) === '[object RegExp]';
+const isEmptyObject = (val) => isPlainObject(val) && Object.keys(val).length === 0;
+const assign = Object.assign;
+const _create = Object.create;
+const create = (obj = null) => _create(obj);
+let _globalThis;
+const getGlobalThis = () => {
+    // prettier-ignore
+    return (_globalThis ||
+        (_globalThis =
+            typeof globalThis !== 'undefined'
+                ? globalThis
+                : typeof self !== 'undefined'
+                    ? self
+                    : typeof window !== 'undefined'
+                        ? window
+                        : typeof global !== 'undefined'
+                            ? global
+                            : create()));
+};
+function escapeHtml(rawText) {
+    return rawText
+        .replace(/&/g, '&amp;') // escape `&` first to avoid double escaping
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;')
+        .replace(/\//g, '&#x2F;') // escape `/` to prevent closing tags or JavaScript URLs
+        .replace(/=/g, '&#x3D;'); // escape `=` to prevent attribute injection
+}
+function escapeAttributeValue(value) {
+    return value
+        .replace(/&(?![a-zA-Z0-9#]{2,6};)/g, '&amp;') // escape unescaped `&`
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&apos;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+function sanitizeTranslatedHtml(html) {
+    // Escape dangerous characters in attribute values
+    // Process attributes with double quotes
+    html = html.replace(/(\w+)\s*=\s*"([^"]*)"/g, (_, attrName, attrValue) => `${attrName}="${escapeAttributeValue(attrValue)}"`);
+    // Process attributes with single quotes
+    html = html.replace(/(\w+)\s*=\s*'([^']*)'/g, (_, attrName, attrValue) => `${attrName}='${escapeAttributeValue(attrValue)}'`);
+    // Detect and neutralize event handler attributes
+    const eventHandlerPattern = /\s*on\w+\s*=\s*["']?[^"'>]+["']?/gi;
+    if (eventHandlerPattern.test(html)) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            warn('Potentially dangerous event handlers detected in translation. ' +
+                'Consider removing onclick, onerror, etc. from your translation messages.');
+        }
+        // Neutralize event handler attributes by escaping 'on'
+        html = html.replace(/(\s+)(on)(\w+\s*=)/gi, '$1&#111;n$3');
+    }
+    // Disable javascript: URLs in various contexts
+    const javascriptUrlPattern = [
+        // In href, src, action, formaction attributes
+        /(\s+(?:href|src|action|formaction)\s*=\s*["']?)\s*javascript:/gi,
+        // In style attributes within url()
+        /(style\s*=\s*["'][^"']*url\s*\(\s*)javascript:/gi
+    ];
+    javascriptUrlPattern.forEach(pattern => {
+        html = html.replace(pattern, '$1javascript&#58;');
+    });
+    return html;
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(obj, key) {
+    return hasOwnProperty.call(obj, key);
+}
+/* eslint-enable */
+/**
+ * Useful Utilities By Evan you
+ * Modified by kazuya kawaguchi
+ * MIT License
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/index.ts
+ * https://github.com/vuejs/vue-next/blob/master/packages/shared/src/codeframe.ts
+ */
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isString = (val) => typeof val === 'string';
+const isBoolean = (val) => typeof val === 'boolean';
+const isSymbol = (val) => typeof val === 'symbol';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isObject = (val) => val !== null && typeof val === 'object';
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isPromise = (val) => {
+    return isObject(val) && isFunction(val.then) && isFunction(val.catch);
+};
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+const isPlainObject = (val) => toTypeString(val) === '[object Object]';
+// for converting list and named values to displayed strings.
+const toDisplayString = (val) => {
+    return val == null
+        ? ''
+        : isArray(val) || (isPlainObject(val) && val.toString === objectToString)
+            ? JSON.stringify(val, null, 2)
+            : String(val);
+};
+function join(items, separator = '') {
+    return items.reduce((str, item, index) => (index === 0 ? str + item : str + separator + item), '');
+}
+const RANGE = 2;
+function generateCodeFrame(source, start = 0, end = source.length) {
+    const lines = source.split(/\r?\n/);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+        count += lines[i].length + 1;
+        if (count >= start) {
+            for (let j = i - RANGE; j <= i + RANGE || end > count; j++) {
+                if (j < 0 || j >= lines.length)
+                    continue;
+                const line = j + 1;
+                res.push(`${line}${' '.repeat(3 - String(line).length)}|  ${lines[j]}`);
+                const lineLength = lines[j].length;
+                if (j === i) {
+                    // push underline
+                    const pad = start - (count - lineLength) + 1;
+                    const length = Math.max(1, end > count ? lineLength - pad : end - start);
+                    res.push(`   |  ` + ' '.repeat(pad) + '^'.repeat(length));
+                }
+                else if (j > i) {
+                    if (end > count) {
+                        const length = Math.max(Math.min(end - count, lineLength), 1);
+                        res.push(`   |  ` + '^'.repeat(length));
+                    }
+                    count += lineLength + 1;
+                }
+            }
+            break;
+        }
+    }
+    return res.join('\n');
+}
+
+/**
+ * Event emitter, forked from the below:
+ * - original repository url: https://github.com/developit/mitt
+ * - code url: https://github.com/developit/mitt/blob/master/src/index.ts
+ * - author: Jason Miller (https://github.com/developit)
+ * - license: MIT
+ */
+/**
+ * Create a event emitter
+ *
+ * @returns An event emitter
+ */
+function createEmitter() {
+    const events = new Map();
+    const emitter = {
+        events,
+        on(event, handler) {
+            const handlers = events.get(event);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                events.set(event, [handler]);
+            }
+        },
+        off(event, handler) {
+            const handlers = events.get(event);
+            if (handlers) {
+                handlers.splice(handlers.indexOf(handler) >>> 0, 1);
+            }
+        },
+        emit(event, payload) {
+            (events.get(event) || [])
+                .slice()
+                .map(handler => handler(payload));
+            (events.get('*') || [])
+                .slice()
+                .map(handler => handler(event, payload));
+        }
+    };
+    return emitter;
+}
+
+const isNotObjectOrIsArray = (val) => !isObject(val) || isArray(val);
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function deepCopy(src, des) {
+    // src and des should both be objects, and none of them can be a array
+    if (isNotObjectOrIsArray(src) || isNotObjectOrIsArray(des)) {
+        throw new Error('Invalid value');
+    }
+    const stack = [{ src, des }];
+    while (stack.length) {
+        const { src, des } = stack.pop();
+        // using `Object.keys` which skips prototype properties
+        Object.keys(src).forEach(key => {
+            if (key === '__proto__') {
+                return;
+            }
+            // if src[key] is an object/array, set des[key]
+            // to empty object/array to prevent setting by reference
+            if (isObject(src[key]) && !isObject(des[key])) {
+                des[key] = Array.isArray(src[key]) ? [] : create();
+            }
+            if (isNotObjectOrIsArray(des[key]) || isNotObjectOrIsArray(src[key])) {
+                // replace with src[key] when:
+                // src[key] or des[key] is not an object, or
+                // src[key] or des[key] is an array
+                des[key] = src[key];
+            }
+            else {
+                // src[key] and des[key] are both objects, merge them
+                stack.push({ src: src[key], des: des[key] });
+            }
+        });
+    }
+}
+
+export { assign, create, createEmitter, deepCopy, escapeHtml, format, friendlyJSONstringify, generateCodeFrame, generateFormatCacheKey, getGlobalThis, hasOwn, inBrowser, isArray, isBoolean, isDate, isEmptyObject, isFunction, isNumber, isObject, isPlainObject, isPromise, isRegExp, isString, isSymbol, join, makeSymbol, mark, measure, objectToString, sanitizeTranslatedHtml, toDisplayString, toTypeString, warn, warnOnce };
--- a/frontend_admin/.output/server/node_modules/@intlify/shared/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/shared/package.json
@@ -0,0 +1,69 @@
+{
+  "name": "@intlify/shared",
+  "version": "11.4.2",
+  "description": "@intlify/shared",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "utitlity"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "homepage": "https://github.com/intlify/vue-i18n/tree/master/packages/shared#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/vue-i18n.git",
+    "directory": "packages/shared"
+  },
+  "bugs": {
+    "url": "https://github.com/intlify/vue-i18n/issues"
+  },
+  "files": [
+    "index.js",
+    "dist"
+  ],
+  "main": "index.js",
+  "module": "dist/shared.mjs",
+  "types": "dist/shared.d.ts",
+  "engines": {
+    "node": ">= 16"
+  },
+  "buildOptions": {
+    "name": "IntlifyShared",
+    "formats": [
+      "mjs",
+      "browser",
+      "cjs"
+    ]
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.mjs",
+      "browser": "./dist/shared.esm-browser.js",
+      "node": {
+        "import": {
+          "production": "./dist/shared.prod.cjs",
+          "development": "./dist/shared.mjs",
+          "default": "./dist/shared.prod.cjs"
+        },
+        "require": {
+          "production": "./dist/shared.prod.cjs",
+          "development": "./dist/shared.cjs",
+          "default": "./dist/shared.prod.cjs"
+        }
+      }
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "funding": "https://github.com/sponsors/kazupon",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false
+}
--- a/frontend_admin/.output/server/node_modules/@intlify/utils/dist/h3.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/utils/dist/h3.mjs
@@ -0,0 +1,89 @@
+import { g as getHeaderLanguagesWithGetter, A as ACCEPT_LANGUAGE_HEADER, p as parseDefaultHeader, m as mapToLocaleFromLanguageTag, a as getLocaleWithGetter, D as DEFAULT_LANG_TAG, b as DEFAULT_COOKIE_NAME, v as validateLocale, d as getPathLocale$1, e as pathLanguageParser, f as getQueryLocale$1 } from './shared/utils.9f8159f5.mjs';
+import { setCookie, getRequestURL, getCookie, getHeaders } from 'h3';
+
+function getHeaderLanguages(event, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  const getter = () => {
+    const headers = getHeaders(event);
+    return headers[name];
+  };
+  return getHeaderLanguagesWithGetter(getter, { name, parser });
+}
+function getHeaderLanguage(event, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  return getHeaderLanguages(event, { name, parser })[0] || "";
+}
+function getHeaderLocales(event, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  return mapToLocaleFromLanguageTag(getHeaderLanguages, event, { name, parser });
+}
+function tryHeaderLocales(event, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  try {
+    return getHeaderLocales(event, { name, parser });
+  } catch {
+    return null;
+  }
+}
+function getHeaderLocale(event, {
+  lang = DEFAULT_LANG_TAG,
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  return getLocaleWithGetter(() => getHeaderLanguages(event, { name, parser })[0] || lang);
+}
+function tryHeaderLocale(event, {
+  lang = DEFAULT_LANG_TAG,
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  try {
+    return getHeaderLocale(event, { lang, name, parser });
+  } catch {
+    return null;
+  }
+}
+function getCookieLocale(event, { lang = DEFAULT_LANG_TAG, name = DEFAULT_COOKIE_NAME } = {}) {
+  return getLocaleWithGetter(() => getCookie(event, name) || lang);
+}
+function tryCookieLocale(event, { lang = DEFAULT_LANG_TAG, name = DEFAULT_COOKIE_NAME } = {}) {
+  try {
+    return getCookieLocale(event, { lang, name });
+  } catch {
+    return null;
+  }
+}
+function setCookieLocale(event, locale, options = { name: DEFAULT_COOKIE_NAME }) {
+  validateLocale(locale);
+  setCookie(event, options.name, locale.toString(), options);
+}
+function getPathLocale(event, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  return getPathLocale$1(getRequestURL(event), { lang, parser });
+}
+function tryPathLocale(event, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  try {
+    return getPathLocale(event, { lang, parser });
+  } catch {
+    return null;
+  }
+}
+function getQueryLocale(event, { lang = DEFAULT_LANG_TAG, name = "locale" } = {}) {
+  return getQueryLocale$1(getRequestURL(event), { lang, name });
+}
+function tryQueryLocale(event, { lang = DEFAULT_LANG_TAG, name = "locale" } = {}) {
+  try {
+    return getQueryLocale(event, { lang, name });
+  } catch {
+    return null;
+  }
+}
+
+export { getCookieLocale, getHeaderLanguage, getHeaderLanguages, getHeaderLocale, getHeaderLocales, getPathLocale, getQueryLocale, setCookieLocale, tryCookieLocale, tryHeaderLocale, tryHeaderLocales, tryPathLocale, tryQueryLocale };
--- a/frontend_admin/.output/server/node_modules/@intlify/utils/dist/shared/utils.9f8159f5.mjs
+++ b/frontend_admin/.output/server/node_modules/@intlify/utils/dist/shared/utils.9f8159f5.mjs
@@ -0,0 +1,108 @@
+const objectToString = Object.prototype.toString;
+const toTypeString = (value) => objectToString.call(value);
+function isURL(val) {
+  return toTypeString(val) === "[object URL]";
+}
+function isURLSearchParams(val) {
+  return toTypeString(val) === "[object URLSearchParams]";
+}
+function isLocale(val) {
+  return toTypeString(val) === "[object Intl.Locale]";
+}
+function toLocale(val) {
+  return isLocale(val) ? val : new Intl.Locale(val);
+}
+function validateLangTag(lang) {
+  try {
+    Intl.getCanonicalLocales(lang);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseAcceptLanguage(value) {
+  return value.split(",").map((tag) => tag.split(";")[0]).filter(
+    (tag) => !(tag === "*" || tag === "")
+  );
+}
+function normalizeLanguageName(langName) {
+  const [lang] = langName.split(".");
+  return lang.replace(/_/g, "-");
+}
+function createPathIndexLanguageParser(index = 0) {
+  return (path) => {
+    const rawPath = typeof path === "string" ? path : path.pathname;
+    const normalizedPath = rawPath.split("?")[0];
+    const parts = normalizedPath.split("/");
+    if (parts[0] === "") {
+      parts.shift();
+    }
+    return parts.length > index ? parts[index] || "" : "";
+  };
+}
+let pathLanguageParser = /* @__PURE__ */ createPathIndexLanguageParser();
+function registerPathLanguageParser(parser) {
+  pathLanguageParser = parser;
+}
+
+const DEFAULT_LANG_TAG = "en-US";
+const DEFAULT_COOKIE_NAME = "i18n_locale";
+const ACCEPT_LANGUAGE_HEADER = "accept-language";
+
+function parseDefaultHeader(input) {
+  return [input];
+}
+function getHeaderLanguagesWithGetter(getter, {
+  name = ACCEPT_LANGUAGE_HEADER,
+  parser = parseDefaultHeader
+} = {}) {
+  const langString = getter();
+  return langString ? name === ACCEPT_LANGUAGE_HEADER ? parser === parseDefaultHeader ? parseAcceptLanguage(langString) : parser(langString) : parser(langString) : [];
+}
+function getLocaleWithGetter(getter) {
+  return toLocale(getter());
+}
+function validateLocale(locale) {
+  if (!(isLocale(locale) || typeof locale === "string" && validateLangTag(locale))) {
+    throw new SyntaxError(`locale is invalid: ${locale.toString()}`);
+  }
+}
+function mapToLocaleFromLanguageTag(getter, ...args) {
+  return Reflect.apply(getter, null, args).map(
+    (lang) => getLocaleWithGetter(() => lang)
+  );
+}
+function getExistCookies(name, getter) {
+  let setCookies = getter();
+  if (!Array.isArray(setCookies)) {
+    setCookies = [setCookies];
+  }
+  setCookies = setCookies.filter(
+    (cookieValue) => cookieValue && !cookieValue.startsWith(name + "=")
+  );
+  return setCookies;
+}
+function getPathLanguage(path, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  return (parser || pathLanguageParser)(path) || lang;
+}
+function getPathLocale(path, { lang = DEFAULT_LANG_TAG, parser = pathLanguageParser } = {}) {
+  return new Intl.Locale(getPathLanguage(path, { lang, parser }));
+}
+function getURLSearchParams(input) {
+  if (isURLSearchParams(input)) {
+    return input;
+  } else if (isURL(input)) {
+    return input.searchParams;
+  } else {
+    return new URLSearchParams(input);
+  }
+}
+function getQueryLanguage(query, { lang = DEFAULT_LANG_TAG, name = "lang" } = {}) {
+  const queryParams = getURLSearchParams(query);
+  return queryParams.get(name) || lang;
+}
+function getQueryLocale(query, { lang = DEFAULT_LANG_TAG, name = "locale" } = {}) {
+  return new Intl.Locale(getQueryLanguage(query, { lang, name }));
+}
+
+export { ACCEPT_LANGUAGE_HEADER as A, DEFAULT_LANG_TAG as D, getLocaleWithGetter as a, DEFAULT_COOKIE_NAME as b, getExistCookies as c, getPathLocale as d, pathLanguageParser as e, getQueryLocale as f, getHeaderLanguagesWithGetter as g, createPathIndexLanguageParser as h, isLocale as i, parseAcceptLanguage as j, validateLangTag as k, mapToLocaleFromLanguageTag as m, normalizeLanguageName as n, parseDefaultHeader as p, registerPathLanguageParser as r, validateLocale as v };
--- a/frontend_admin/.output/server/node_modules/@intlify/utils/package.json
+++ b/frontend_admin/.output/server/node_modules/@intlify/utils/package.json
@@ -0,0 +1,129 @@
+{
+  "name": "@intlify/utils",
+  "version": "0.13.0",
+  "description": "Collection of i18n utilities",
+  "keywords": [
+    "i18n",
+    "internationalization",
+    "intlify",
+    "utilities"
+  ],
+  "author": {
+    "name": "kazuya kawaguchi",
+    "email": "kawakazu80@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/kazupon",
+  "bugs": {
+    "url": "https://github.com/intlify/utils/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/intlify/utils.git"
+  },
+  "homepage": "https://github.com/intlify/utils#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "browser": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./h3": {
+      "types": "./dist/h3.d.ts",
+      "import": "./dist/h3.mjs",
+      "require": "./dist/h3.cjs",
+      "default": "./dist/h3.mjs"
+    },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "import": "./dist/hono.mjs",
+      "require": "./dist/hono.cjs",
+      "default": "./dist/hono.mjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.mjs",
+      "require": "./dist/node.cjs",
+      "default": "./dist/node.mjs"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepare": "git config --local core.hooksPath .githooks",
+    "changelog": "gh-changelogen --repo=intlify/utils",
+    "release": "bumpp --commit \"release: v%s\" --all --push --tag",
+    "version": "npx tsx scripts/bump-deno.ts",
+    "fix": "run-p lint format",
+    "lint": "deno lint",
+    "format": "deno fmt",
+    "build": "unbuild && bun run ./scripts/deno.ts",
+    "test": "npm run test:typecheck && npm run test:unit",
+    "test:unit": "NODE_OPTIONS=--experimental-vm-modules vitest run ./src",
+    "test:typecheck": "vitest --typecheck --config ./vitest.type.config.ts --run",
+    "test:coverage": "npm test -- --reporter verbose --coverage",
+    "test:e2e": "run-s test:e2e:*",
+    "test:e2e:browser": "cd playground/browser && node --test",
+    "test:e2e:node": "cd playground/node && node --test",
+    "test:e2e:deno": "cd playground/deno && deno task test",
+    "test:e2e:bun": "cd playground/bun && npm run test",
+    "setup": "run-s setup:*",
+    "setup:browser": "cd playground/browser && bun install",
+    "setup:node": "cd playground/node && bun install",
+    "setup:deno": "cd playground/deno && deno cache --reload ./main.ts",
+    "setup:bun": "cd playground/bun && bun install",
+    "play:browser": "cd playground/browser && npm run dev",
+    "play:node": "cd playground/node && npm run dev",
+    "play:deno": "cd playground/deno && deno run --allow-net main.ts",
+    "play:bun": "cd playground/bun && npm run dev"
+  },
+  "lint-staged": {
+    "*.{js,ts,jsx,tsx,json,jsonc}": [
+      "deno fmt"
+    ],
+    "*.{js,ts,jsx,tsx}": [
+      "deno lint"
+    ]
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20231016.0",
+    "@types/node": "^20.11.24",
+    "@types/semver": "^7.5.8",
+    "@types/supertest": "^2.0.12",
+    "@vitest/coverage-v8": "^1.3.0",
+    "bumpp": "^9.2.0",
+    "bun-types": "latest",
+    "cookie-es": "^1.0.0",
+    "gh-changelogen": "^0.2.8",
+    "h3": "^1.8.1",
+    "hono": "^3.8.1",
+    "jsonc-parser": "^3.2.1",
+    "lint-staged": "^15.0.0",
+    "miniflare": "^3.20231016.0",
+    "npm-run-all2": "^6.0.0",
+    "pkg-types": "^1.0.2",
+    "playwright": "^1.38.1",
+    "semver": "^7.6.0",
+    "supertest": "^6.3.3",
+    "typescript": "^5.4.1-rc",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.3.0",
+    "vitest-environment-miniflare": "^2.14.1"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/@vue/devtools-api
+++ b/frontend_admin/.output/server/node_modules/@vue/devtools-api
@@ -1 +1 @@
-../.nitro/@vue/devtools-api@7.7.9
+../.nitro/@vue/devtools-api@8.1.3
--- a/frontend_admin/.output/server/node_modules/@vue/devtools-kit
+++ b/frontend_admin/.output/server/node_modules/@vue/devtools-kit
@@ -0,0 +1 @@
+../.nitro/@vue/devtools-kit@8.1.3
--- a/frontend_admin/.output/server/node_modules/@vue/devtools-kit/node_modules/hookable
+++ b/frontend_admin/.output/server/node_modules/@vue/devtools-kit/node_modules/hookable
@@ -1 +0,0 @@
-../../../.nitro/hookable@5.5.3
--- a/frontend_admin/.output/server/node_modules/@vue/devtools-shared
+++ b/frontend_admin/.output/server/node_modules/@vue/devtools-shared
@@ -0,0 +1 @@
+../.nitro/@vue/devtools-shared@8.1.3
--- a/frontend_admin/.output/server/node_modules/birpc/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/birpc/dist/index.mjs
@@ -0,0 +1,291 @@
+const TYPE_REQUEST = "q";
+const TYPE_RESPONSE = "s";
+const DEFAULT_TIMEOUT = 6e4;
+function defaultSerialize(i) {
+  return i;
+}
+const defaultDeserialize = defaultSerialize;
+const { clearTimeout, setTimeout } = globalThis;
+const random = Math.random.bind(Math);
+function createBirpc($functions, options) {
+  const {
+    post,
+    on,
+    off = () => {
+    },
+    eventNames = [],
+    serialize = defaultSerialize,
+    deserialize = defaultDeserialize,
+    resolver,
+    bind = "rpc",
+    timeout = DEFAULT_TIMEOUT
+  } = options;
+  let $closed = false;
+  const _rpcPromiseMap = /* @__PURE__ */ new Map();
+  let _promiseInit;
+  let rpc;
+  async function _call(method, args, event, optional) {
+    if ($closed)
+      throw new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+    const req = { m: method, a: args, t: TYPE_REQUEST };
+    if (optional)
+      req.o = true;
+    const send = async (_req) => post(serialize(_req));
+    if (event) {
+      await send(req);
+      return;
+    }
+    if (_promiseInit) {
+      try {
+        await _promiseInit;
+      } finally {
+        _promiseInit = void 0;
+      }
+    }
+    let { promise, resolve, reject } = createPromiseWithResolvers();
+    const id = nanoid();
+    req.i = id;
+    let timeoutId;
+    async function handler(newReq = req) {
+      if (timeout >= 0) {
+        timeoutId = setTimeout(() => {
+          try {
+            const handleResult = options.onTimeoutError?.call(rpc, method, args);
+            if (handleResult !== true)
+              throw new Error(`[birpc] timeout on calling "${method}"`);
+          } catch (e) {
+            reject(e);
+          }
+          _rpcPromiseMap.delete(id);
+        }, timeout);
+        if (typeof timeoutId === "object")
+          timeoutId = timeoutId.unref?.();
+      }
+      _rpcPromiseMap.set(id, { resolve, reject, timeoutId, method });
+      await send(newReq);
+      return promise;
+    }
+    try {
+      if (options.onRequest)
+        await options.onRequest.call(rpc, req, handler, resolve);
+      else
+        await handler();
+    } catch (e) {
+      if (options.onGeneralError?.call(rpc, e) !== true)
+        throw e;
+      return;
+    } finally {
+      clearTimeout(timeoutId);
+      _rpcPromiseMap.delete(id);
+    }
+    return promise;
+  }
+  const $call = (method, ...args) => _call(method, args, false);
+  const $callOptional = (method, ...args) => _call(method, args, false, true);
+  const $callEvent = (method, ...args) => _call(method, args, true);
+  const $callRaw = (options2) => _call(options2.method, options2.args, options2.event, options2.optional);
+  const builtinMethods = {
+    $call,
+    $callOptional,
+    $callEvent,
+    $callRaw,
+    $rejectPendingCalls,
+    get $closed() {
+      return $closed;
+    },
+    get $meta() {
+      return options.meta;
+    },
+    $close,
+    $functions
+  };
+  rpc = new Proxy({}, {
+    get(_, method) {
+      if (Object.prototype.hasOwnProperty.call(builtinMethods, method))
+        return builtinMethods[method];
+      if (method === "then" && !eventNames.includes("then") && !("then" in $functions))
+        return void 0;
+      const sendEvent = (...args) => _call(method, args, true);
+      if (eventNames.includes(method)) {
+        sendEvent.asEvent = sendEvent;
+        return sendEvent;
+      }
+      const sendCall = (...args) => _call(method, args, false);
+      sendCall.asEvent = sendEvent;
+      return sendCall;
+    }
+  });
+  function $close(customError) {
+    $closed = true;
+    _rpcPromiseMap.forEach(({ reject, method }) => {
+      const error = new Error(`[birpc] rpc is closed, cannot call "${method}"`);
+      if (customError) {
+        customError.cause ??= error;
+        return reject(customError);
+      }
+      reject(error);
+    });
+    _rpcPromiseMap.clear();
+    off(onMessage);
+  }
+  function $rejectPendingCalls(handler) {
+    const entries = Array.from(_rpcPromiseMap.values());
+    const handlerResults = entries.map(({ method, reject }) => {
+      if (!handler) {
+        return reject(new Error(`[birpc]: rejected pending call "${method}".`));
+      }
+      return handler({ method, reject });
+    });
+    _rpcPromiseMap.clear();
+    return handlerResults;
+  }
+  async function onMessage(data, ...extra) {
+    let msg;
+    try {
+      msg = deserialize(data);
+    } catch (e) {
+      if (options.onGeneralError?.call(rpc, e) !== true)
+        throw e;
+      return;
+    }
+    if (msg.t === TYPE_REQUEST) {
+      const { m: method, a: args, o: optional } = msg;
+      let result, error;
+      let fn = await (resolver ? resolver.call(rpc, method, $functions[method]) : $functions[method]);
+      if (optional)
+        fn ||= () => void 0;
+      if (!fn) {
+        error = new Error(`[birpc] function "${method}" not found`);
+      } else {
+        try {
+          result = await fn.apply(bind === "rpc" ? rpc : $functions, args);
+        } catch (e) {
+          error = e;
+        }
+      }
+      if (msg.i) {
+        if (error && options.onError)
+          options.onError.call(rpc, error, method, args);
+        if (error && options.onFunctionError) {
+          if (options.onFunctionError.call(rpc, error, method, args) === true)
+            return;
+        }
+        if (!error) {
+          try {
+            await post(serialize({ t: TYPE_RESPONSE, i: msg.i, r: result }), ...extra);
+            return;
+          } catch (e) {
+            error = e;
+            if (options.onGeneralError?.call(rpc, e, method, args) !== true)
+              throw e;
+          }
+        }
+        try {
+          await post(serialize({ t: TYPE_RESPONSE, i: msg.i, e: error }), ...extra);
+        } catch (e) {
+          if (options.onGeneralError?.call(rpc, e, method, args) !== true)
+            throw e;
+        }
+      }
+    } else {
+      const { i: ack, r: result, e: error } = msg;
+      const promise = _rpcPromiseMap.get(ack);
+      if (promise) {
+        clearTimeout(promise.timeoutId);
+        if (error)
+          promise.reject(error);
+        else
+          promise.resolve(result);
+      }
+      _rpcPromiseMap.delete(ack);
+    }
+  }
+  _promiseInit = on(onMessage);
+  return rpc;
+}
+const cacheMap = /* @__PURE__ */ new WeakMap();
+function cachedMap(items, fn) {
+  return items.map((i) => {
+    let r = cacheMap.get(i);
+    if (!r) {
+      r = fn(i);
+      cacheMap.set(i, r);
+    }
+    return r;
+  });
+}
+function createBirpcGroup(functions, channels, options = {}) {
+  const getChannels = () => typeof channels === "function" ? channels() : channels;
+  const getClients = (channels2 = getChannels()) => cachedMap(channels2, (s) => createBirpc(functions, { ...options, ...s }));
+  function _boardcast(method, args, event, optional) {
+    const clients = getClients();
+    return Promise.all(clients.map((c) => c.$callRaw({ method, args, event, optional })));
+  }
+  function $call(method, ...args) {
+    return _boardcast(method, args, false);
+  }
+  function $callOptional(method, ...args) {
+    return _boardcast(method, args, false, true);
+  }
+  function $callEvent(method, ...args) {
+    return _boardcast(method, args, true);
+  }
+  const broadcastBuiltin = {
+    $call,
+    $callOptional,
+    $callEvent
+  };
+  const broadcastProxy = new Proxy({}, {
+    get(_, method) {
+      if (Object.prototype.hasOwnProperty.call(broadcastBuiltin, method))
+        return broadcastBuiltin[method];
+      const client = getClients();
+      const callbacks = client.map((c) => c[method]);
+      const sendCall = (...args) => {
+        return Promise.all(callbacks.map((i) => i(...args)));
+      };
+      sendCall.asEvent = async (...args) => {
+        await Promise.all(callbacks.map((i) => i.asEvent(...args)));
+      };
+      return sendCall;
+    }
+  });
+  function updateChannels(fn) {
+    const channels2 = getChannels();
+    fn?.(channels2);
+    return getClients(channels2);
+  }
+  getClients();
+  return {
+    get clients() {
+      return getClients();
+    },
+    functions,
+    updateChannels,
+    broadcast: broadcastProxy,
+    /**
+     * @deprecated use `broadcast`
+     */
+    // @ts-expect-error deprecated
+    boardcast: broadcastProxy
+  };
+}
+function createPromiseWithResolvers() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+const urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+function nanoid(size = 21) {
+  let id = "";
+  let i = size;
+  while (i--)
+    id += urlAlphabet[random() * 64 | 0];
+  return id;
+}
+
+export { DEFAULT_TIMEOUT, cachedMap, createBirpc, createBirpcGroup };
--- a/frontend_admin/.output/server/node_modules/cookie-es/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/cookie-es/dist/index.mjs
@@ -0,0 +1,268 @@
+const NullObject = /* @__PURE__ */ (() => {
+  const C = function() {
+  };
+  C.prototype = /* @__PURE__ */ Object.create(null);
+  return C;
+})();
+function parse(str, options) {
+  if (typeof str !== "string") {
+    throw new TypeError("argument str must be a string");
+  }
+  const obj = new NullObject();
+  const opt = options || {};
+  const dec = opt.decode || decode;
+  let index = 0;
+  while (index < str.length) {
+    const eqIdx = str.indexOf("=", index);
+    if (eqIdx === -1) {
+      break;
+    }
+    let endIdx = str.indexOf(";", index);
+    if (endIdx === -1) {
+      endIdx = str.length;
+    } else if (endIdx < eqIdx) {
+      index = str.lastIndexOf(";", eqIdx - 1) + 1;
+      continue;
+    }
+    const key = str.slice(index, eqIdx).trim();
+    if (opt?.filter && !opt?.filter(key)) {
+      index = endIdx + 1;
+      continue;
+    }
+    if (void 0 === obj[key]) {
+      let val = str.slice(eqIdx + 1, endIdx).trim();
+      if (val.codePointAt(0) === 34) {
+        val = val.slice(1, -1);
+      }
+      obj[key] = tryDecode(val, dec);
+    }
+    index = endIdx + 1;
+  }
+  return obj;
+}
+function decode(str) {
+  return str.includes("%") ? decodeURIComponent(str) : str;
+}
+function tryDecode(str, decode2) {
+  try {
+    return decode2(str);
+  } catch {
+    return str;
+  }
+}
+
+const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
+function serialize(name, value, options) {
+  const opt = options || {};
+  const enc = opt.encode || encodeURIComponent;
+  if (typeof enc !== "function") {
+    throw new TypeError("option encode is invalid");
+  }
+  if (!fieldContentRegExp.test(name)) {
+    throw new TypeError("argument name is invalid");
+  }
+  const encodedValue = enc(value);
+  if (encodedValue && !fieldContentRegExp.test(encodedValue)) {
+    throw new TypeError("argument val is invalid");
+  }
+  let str = name + "=" + encodedValue;
+  if (void 0 !== opt.maxAge && opt.maxAge !== null) {
+    const maxAge = opt.maxAge - 0;
+    if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) {
+      throw new TypeError("option maxAge is invalid");
+    }
+    str += "; Max-Age=" + Math.floor(maxAge);
+  }
+  if (opt.domain) {
+    if (!fieldContentRegExp.test(opt.domain)) {
+      throw new TypeError("option domain is invalid");
+    }
+    str += "; Domain=" + opt.domain;
+  }
+  if (opt.path) {
+    if (!fieldContentRegExp.test(opt.path)) {
+      throw new TypeError("option path is invalid");
+    }
+    str += "; Path=" + opt.path;
+  }
+  if (opt.expires) {
+    if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) {
+      throw new TypeError("option expires is invalid");
+    }
+    str += "; Expires=" + opt.expires.toUTCString();
+  }
+  if (opt.httpOnly) {
+    str += "; HttpOnly";
+  }
+  if (opt.secure) {
+    str += "; Secure";
+  }
+  if (opt.priority) {
+    const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
+    switch (priority) {
+      case "low": {
+        str += "; Priority=Low";
+        break;
+      }
+      case "medium": {
+        str += "; Priority=Medium";
+        break;
+      }
+      case "high": {
+        str += "; Priority=High";
+        break;
+      }
+      default: {
+        throw new TypeError("option priority is invalid");
+      }
+    }
+  }
+  if (opt.sameSite) {
+    const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
+    switch (sameSite) {
+      case true: {
+        str += "; SameSite=Strict";
+        break;
+      }
+      case "lax": {
+        str += "; SameSite=Lax";
+        break;
+      }
+      case "strict": {
+        str += "; SameSite=Strict";
+        break;
+      }
+      case "none": {
+        str += "; SameSite=None";
+        break;
+      }
+      default: {
+        throw new TypeError("option sameSite is invalid");
+      }
+    }
+  }
+  if (opt.partitioned) {
+    str += "; Partitioned";
+  }
+  return str;
+}
+function isDate(val) {
+  return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
+}
+
+function parseSetCookie(setCookieValue, options) {
+  const parts = (setCookieValue || "").split(";").filter((str) => typeof str === "string" && !!str.trim());
+  const nameValuePairStr = parts.shift() || "";
+  const parsed = _parseNameValuePair(nameValuePairStr);
+  const name = parsed.name;
+  let value = parsed.value;
+  try {
+    value = options?.decode === false ? value : (options?.decode || decodeURIComponent)(value);
+  } catch {
+  }
+  const cookie = {
+    name,
+    value
+  };
+  for (const part of parts) {
+    const sides = part.split("=");
+    const partKey = (sides.shift() || "").trimStart().toLowerCase();
+    const partValue = sides.join("=");
+    switch (partKey) {
+      case "expires": {
+        cookie.expires = new Date(partValue);
+        break;
+      }
+      case "max-age": {
+        cookie.maxAge = Number.parseInt(partValue, 10);
+        break;
+      }
+      case "secure": {
+        cookie.secure = true;
+        break;
+      }
+      case "httponly": {
+        cookie.httpOnly = true;
+        break;
+      }
+      case "samesite": {
+        cookie.sameSite = partValue;
+        break;
+      }
+      default: {
+        cookie[partKey] = partValue;
+      }
+    }
+  }
+  return cookie;
+}
+function _parseNameValuePair(nameValuePairStr) {
+  let name = "";
+  let value = "";
+  const nameValueArr = nameValuePairStr.split("=");
+  if (nameValueArr.length > 1) {
+    name = nameValueArr.shift();
+    value = nameValueArr.join("=");
+  } else {
+    value = nameValuePairStr;
+  }
+  return { name, value };
+}
+
+function splitSetCookieString(cookiesString) {
+  if (Array.isArray(cookiesString)) {
+    return cookiesString.flatMap((c) => splitSetCookieString(c));
+  }
+  if (typeof cookiesString !== "string") {
+    return [];
+  }
+  const cookiesStrings = [];
+  let pos = 0;
+  let start;
+  let ch;
+  let lastComma;
+  let nextStart;
+  let cookiesSeparatorFound;
+  const skipWhitespace = () => {
+    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
+      pos += 1;
+    }
+    return pos < cookiesString.length;
+  };
+  const notSpecialChar = () => {
+    ch = cookiesString.charAt(pos);
+    return ch !== "=" && ch !== ";" && ch !== ",";
+  };
+  while (pos < cookiesString.length) {
+    start = pos;
+    cookiesSeparatorFound = false;
+    while (skipWhitespace()) {
+      ch = cookiesString.charAt(pos);
+      if (ch === ",") {
+        lastComma = pos;
+        pos += 1;
+        skipWhitespace();
+        nextStart = pos;
+        while (pos < cookiesString.length && notSpecialChar()) {
+          pos += 1;
+        }
+        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
+          cookiesSeparatorFound = true;
+          pos = nextStart;
+          cookiesStrings.push(cookiesString.slice(start, lastComma));
+          start = pos;
+        } else {
+          pos = lastComma + 1;
+        }
+      } else {
+        pos += 1;
+      }
+    }
+    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
+      cookiesStrings.push(cookiesString.slice(start, cookiesString.length));
+    }
+  }
+  return cookiesStrings;
+}
+
+export { parse, parseSetCookie, serialize, splitSetCookieString };
--- a/frontend_admin/.output/server/node_modules/cookie-es/package.json
+++ b/frontend_admin/.output/server/node_modules/cookie-es/package.json
@@ -0,0 +1,46 @@
+{
+  "name": "cookie-es",
+  "version": "1.2.3",
+  "repository": "unjs/cookie-es",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest --coverage",
+    "lint": "eslint --cache . && prettier -c src test",
+    "lint:fix": "automd && eslint --cache . --fix && prettier -c src test -w",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish --tag 1x",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^2.0.3",
+    "automd": "^0.3.8",
+    "changelogen": "^0.5.5",
+    "eslint": "^9.7.0",
+    "eslint-config-unjs": "^0.3.2",
+    "prettier": "^3.3.3",
+    "typescript": "^5.5.3",
+    "unbuild": "^2.0.0",
+    "vitest": "^2.0.3"
+  },
+  "packageManager": "pnpm@9.5.0"
+}
--- a/frontend_admin/.output/server/node_modules/defu/dist/defu.mjs
+++ b/frontend_admin/.output/server/node_modules/defu/dist/defu.mjs
@@ -0,0 +1,69 @@
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = { ...defaults };
+  for (const key of Object.keys(baseObject)) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
+    }
+  }
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
+const defuFn = createDefu((object, key, currentValue) => {
+  if (object[key] !== void 0 && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+const defuArrayFn = createDefu((object, key, currentValue) => {
+  if (Array.isArray(object[key]) && typeof currentValue === "function") {
+    object[key] = currentValue(object[key]);
+    return true;
+  }
+});
+
+export { createDefu, defu as default, defu, defuArrayFn, defuFn };
--- a/frontend_admin/.output/server/node_modules/defu/package.json
+++ b/frontend_admin/.output/server/node_modules/defu/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "defu",
+  "version": "6.1.7",
+  "description": "Recursively assign default properties. Lightweight and Fast!",
+  "license": "MIT",
+  "repository": "unjs/defu",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "main": "./lib/defu.cjs",
+  "module": "./dist/defu.mjs",
+  "types": "./dist/defu.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/defu.d.mts",
+        "default": "./dist/defu.mjs"
+      },
+      "require": {
+        "types": "./lib/defu.d.cts",
+        "default": "./lib/defu.cjs"
+      }
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@typescript/native-preview": "7.0.0-dev.20260401.1",
+    "@vitest/coverage-v8": "^4.1.2",
+    "changelogen": "^0.6.2",
+    "eslint-config-unjs": "^0.6.2",
+    "expect-type": "^1.3.0",
+    "oxfmt": "^0.43.0",
+    "oxlint": "^1.58.0",
+    "typescript": "^6.0.2",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.1.2"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "oxlint src && oxfmt --check src test",
+    "lint:fix": "oxlint src --fix && oxfmt src test",
+    "release": "pnpm test && pnpm build && changelogen --release && git push --follow-tags && pnpm publish",
+    "test": "pnpm lint && pnpm test:types && pnpm vitest run",
+    "test:types": "tsgo --noEmit"
+  }
+}
--- a/frontend_admin/.output/server/node_modules/destr/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/destr/dist/index.mjs
@@ -0,0 +1,72 @@
+const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
+const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
+const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
+function jsonParseTransform(key, value) {
+  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
+    warnKeyDropped(key);
+    return;
+  }
+  return value;
+}
+function warnKeyDropped(key) {
+  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
+}
+function destr(value, options = {}) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  if (value[0] === '"' && value[value.length - 1] === '"' && value.indexOf("\\") === -1) {
+    return value.slice(1, -1);
+  }
+  const _value = value.trim();
+  if (_value.length <= 9) {
+    switch (_value.toLowerCase()) {
+      case "true": {
+        return true;
+      }
+      case "false": {
+        return false;
+      }
+      case "undefined": {
+        return void 0;
+      }
+      case "null": {
+        return null;
+      }
+      case "nan": {
+        return Number.NaN;
+      }
+      case "infinity": {
+        return Number.POSITIVE_INFINITY;
+      }
+      case "-infinity": {
+        return Number.NEGATIVE_INFINITY;
+      }
+    }
+  }
+  if (!JsonSigRx.test(value)) {
+    if (options.strict) {
+      throw new SyntaxError("[destr] Invalid JSON");
+    }
+    return value;
+  }
+  try {
+    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
+      if (options.strict) {
+        throw new Error("[destr] Possible prototype pollution");
+      }
+      return JSON.parse(value, jsonParseTransform);
+    }
+    return JSON.parse(value);
+  } catch (error) {
+    if (options.strict) {
+      throw error;
+    }
+    return value;
+  }
+}
+function safeDestr(value, options = {}) {
+  return destr(value, { ...options, strict: true });
+}
+
+export { destr as default, destr, safeDestr };
--- a/frontend_admin/.output/server/node_modules/destr/package.json
+++ b/frontend_admin/.output/server/node_modules/destr/package.json
@@ -0,0 +1,47 @@
+{
+  "name": "destr",
+  "version": "2.0.5",
+  "description": "A faster, secure and convenient alternative for JSON.parse",
+  "repository": "unjs/destr",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./lib/index.cjs"
+    }
+  },
+  "main": "./lib/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "scripts": {
+    "bench:bun": "pnpm build && bun --bun ./test/bench.mjs",
+    "bench:node": "pnpm build && node ./test/bench.mjs",
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c src test",
+    "lint:fix": "eslint . --fix && prettier -w src test",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "devDependencies": {
+    "@hapi/bourne": "^3.0.0",
+    "@vitest/coverage-v8": "^3.1.1",
+    "changelogen": "^0.6.1",
+    "eslint": "^9.23.0",
+    "eslint-config-unjs": "^0.4.2",
+    "mitata": "^1.0.34",
+    "prettier": "^3.5.3",
+    "secure-json-parse": "^4.0.0",
+    "typescript": "^5.8.2",
+    "unbuild": "~3.4",
+    "vitest": "^3.1.1"
+  },
+  "packageManager": "pnpm@10.7.1"
+}
--- a/frontend_admin/.output/server/node_modules/h3/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/h3/dist/index.mjs
--- a/frontend_admin/.output/server/node_modules/h3/package.json
+++ b/frontend_admin/.output/server/node_modules/h3/package.json
@@ -0,0 +1,75 @@
+{
+  "name": "h3",
+  "version": "1.15.11",
+  "description": "Minimal H(TTP) framework built for high performance and portability.",
+  "license": "MIT",
+  "repository": "h3js/h3",
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --cache . && prettier -c src test playground examples docs",
+    "lint:fix": "eslint --cache . --fix && prettier -c src test playground examples docs -w",
+    "prepack": "pnpm build",
+    "play": "listhen -w ./playground/app.ts",
+    "profile": "0x -o -D .profile -P 'autocannon -c 100 -p 10 -d 40 http://localhost:$PORT' ./playground/server.cjs",
+    "release": "pnpm test && pnpm build && changelogen --release --publish --publishTag 1x && git push --follow-tags",
+    "test": "pnpm lint && vitest --run --coverage && pnpm test:types",
+    "test:types": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "cookie-es": "^1.2.3",
+    "crossws": "^0.3.5",
+    "defu": "^6.1.6",
+    "destr": "^2.0.5",
+    "iron-webcrypto": "^1.2.1",
+    "node-mock-http": "^1.0.4",
+    "radix3": "^1.1.2",
+    "ufo": "^1.6.3",
+    "uncrypto": "^0.1.3"
+  },
+  "devDependencies": {
+    "0x": "^6.0.0",
+    "@types/express": "^5.0.6",
+    "@types/node": "^25.5.0",
+    "@types/supertest": "^7.2.0",
+    "@typescript/native-preview": "latest",
+    "@vitest/coverage-v8": "^4.1.2",
+    "autocannon": "^8.0.0",
+    "automd": "^0.4.3",
+    "changelogen": "^0.6.2",
+    "connect": "^3.7.0",
+    "eslint": "^10.1.0",
+    "eslint-config-unjs": "^0.6.2",
+    "express": "^5.2.1",
+    "get-port": "^7.2.0",
+    "h3": "^1.15.10",
+    "jiti": "^2.6.1",
+    "listhen": "^1.9.0",
+    "node-fetch-native": "^1.6.7",
+    "prettier": "^3.8.1",
+    "react": "^19.2.4",
+    "react-dom": "^19.2.4",
+    "supertest": "^7.2.2",
+    "typescript": "^6.0.2",
+    "unbuild": "^3.6.1",
+    "undici": "^7.24.7",
+    "vitest": "^4.1.2",
+    "zod": "^4.3.6"
+  },
+  "packageManager": "pnpm@10.28.0"
+}
--- a/frontend_admin/.output/server/node_modules/iron-webcrypto/dist/index.js
+++ b/frontend_admin/.output/server/node_modules/iron-webcrypto/dist/index.js
@@ -0,0 +1,298 @@
+// src/utils.ts
+var alphabetByEncoding = {};
+var alphabetByValue = Array.from({ length: 64 });
+for (let i = 0, start = "A".charCodeAt(0), limit = "Z".charCodeAt(0); i + start <= limit; i++) {
+  const char = String.fromCharCode(i + start);
+  alphabetByEncoding[char] = i;
+  alphabetByValue[i] = char;
+}
+for (let i = 0, start = "a".charCodeAt(0), limit = "z".charCodeAt(0); i + start <= limit; i++) {
+  const char = String.fromCharCode(i + start);
+  const index = i + 26;
+  alphabetByEncoding[char] = index;
+  alphabetByValue[index] = char;
+}
+for (let i = 0; i < 10; i++) {
+  alphabetByEncoding[i.toString(10)] = i + 52;
+  const char = i.toString(10);
+  const index = i + 52;
+  alphabetByEncoding[char] = index;
+  alphabetByValue[index] = char;
+}
+alphabetByEncoding["-"] = 62;
+alphabetByValue[62] = "-";
+alphabetByEncoding["_"] = 63;
+alphabetByValue[63] = "_";
+var bitsPerLetter = 6;
+var bitsPerByte = 8;
+var maxLetterValue = 63;
+var stringToBuffer = (value) => {
+  return new TextEncoder().encode(value);
+};
+var bufferToString = (value) => {
+  return new TextDecoder().decode(value);
+};
+var base64urlDecode = (_input) => {
+  const input = _input + "=".repeat((4 - _input.length % 4) % 4);
+  let totalByteLength = input.length / 4 * 3;
+  if (input.endsWith("==")) {
+    totalByteLength -= 2;
+  } else if (input.endsWith("=")) {
+    totalByteLength--;
+  }
+  const out = new ArrayBuffer(totalByteLength);
+  const dataView = new DataView(out);
+  for (let i = 0; i < input.length; i += 4) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = i + 3; j <= limit; j++) {
+      if (input[j] === "=") {
+        bits >>= bitsPerLetter;
+      } else {
+        if (!(input[j] in alphabetByEncoding)) {
+          throw new TypeError(`Invalid character ${input[j]} in base64 string.`);
+        }
+        bits |= alphabetByEncoding[input[j]] << (limit - j) * bitsPerLetter;
+        bitLength += bitsPerLetter;
+      }
+    }
+    const chunkOffset = i / 4 * 3;
+    bits >>= bitLength % bitsPerByte;
+    const byteLength = Math.floor(bitLength / bitsPerByte);
+    for (let k = 0; k < byteLength; k++) {
+      const offset = (byteLength - k - 1) * bitsPerByte;
+      dataView.setUint8(chunkOffset + k, (bits & 255 << offset) >> offset);
+    }
+  }
+  return new Uint8Array(out);
+};
+var base64urlEncode = (_input) => {
+  const input = typeof _input === "string" ? stringToBuffer(_input) : _input;
+  let str = "";
+  for (let i = 0; i < input.length; i += 3) {
+    let bits = 0;
+    let bitLength = 0;
+    for (let j = i, limit = Math.min(i + 3, input.length); j < limit; j++) {
+      bits |= input[j] << (limit - j - 1) * bitsPerByte;
+      bitLength += bitsPerByte;
+    }
+    const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
+    bits <<= bitClusterCount * bitsPerLetter - bitLength;
+    for (let k = 1; k <= bitClusterCount; k++) {
+      const offset = (bitClusterCount - k) * bitsPerLetter;
+      str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
+    }
+  }
+  return str;
+};
+
+// src/index.ts
+var defaults = {
+  encryption: { saltBits: 256, algorithm: "aes-256-cbc", iterations: 1, minPasswordlength: 32 },
+  integrity: { saltBits: 256, algorithm: "sha256", iterations: 1, minPasswordlength: 32 },
+  ttl: 0,
+  timestampSkewSec: 60,
+  localtimeOffsetMsec: 0
+};
+var clone = (options) => ({
+  ...options,
+  encryption: { ...options.encryption },
+  integrity: { ...options.integrity }
+});
+var algorithms = {
+  "aes-128-ctr": { keyBits: 128, ivBits: 128, name: "AES-CTR" },
+  "aes-256-cbc": { keyBits: 256, ivBits: 128, name: "AES-CBC" },
+  sha256: { keyBits: 256, name: "SHA-256" }
+};
+var macFormatVersion = "2";
+var macPrefix = "Fe26.2";
+var randomBytes = (_crypto, size) => {
+  const bytes = new Uint8Array(size);
+  _crypto.getRandomValues(bytes);
+  return bytes;
+};
+var randomBits = (_crypto, bits) => {
+  if (bits < 1)
+    throw new Error("Invalid random bits count");
+  const bytes = Math.ceil(bits / 8);
+  return randomBytes(_crypto, bytes);
+};
+var pbkdf2 = async (_crypto, password, salt, iterations, keyLength, hash) => {
+  const passwordBuffer = stringToBuffer(password);
+  const importedKey = await _crypto.subtle.importKey(
+    "raw",
+    passwordBuffer,
+    { name: "PBKDF2" },
+    false,
+    ["deriveBits"]
+  );
+  const saltBuffer = stringToBuffer(salt);
+  const params = { name: "PBKDF2", hash, salt: saltBuffer, iterations };
+  const derivation = await _crypto.subtle.deriveBits(params, importedKey, keyLength * 8);
+  return derivation;
+};
+var generateKey = async (_crypto, password, options) => {
+  var _a;
+  if (!(password == null ? void 0 : password.length))
+    throw new Error("Empty password");
+  if (options == null || typeof options !== "object")
+    throw new Error("Bad options");
+  if (!(options.algorithm in algorithms))
+    throw new Error(`Unknown algorithm: ${options.algorithm}`);
+  const algorithm = algorithms[options.algorithm];
+  const result = {};
+  const hmac = (_a = options.hmac) != null ? _a : false;
+  const id = hmac ? { name: "HMAC", hash: algorithm.name } : { name: algorithm.name };
+  const usage = hmac ? ["sign", "verify"] : ["encrypt", "decrypt"];
+  if (typeof password === "string") {
+    if (password.length < options.minPasswordlength)
+      throw new Error(
+        `Password string too short (min ${options.minPasswordlength} characters required)`
+      );
+    let { salt = "" } = options;
+    if (!salt) {
+      const { saltBits = 0 } = options;
+      if (!saltBits)
+        throw new Error("Missing salt and saltBits options");
+      const randomSalt = randomBits(_crypto, saltBits);
+      salt = [...new Uint8Array(randomSalt)].map((x) => x.toString(16).padStart(2, "0")).join("");
+    }
+    const derivedKey = await pbkdf2(
+      _crypto,
+      password,
+      salt,
+      options.iterations,
+      algorithm.keyBits / 8,
+      "SHA-1"
+    );
+    const importedEncryptionKey = await _crypto.subtle.importKey(
+      "raw",
+      derivedKey,
+      id,
+      false,
+      usage
+    );
+    result.key = importedEncryptionKey;
+    result.salt = salt;
+  } else {
+    if (password.length < algorithm.keyBits / 8)
+      throw new Error("Key buffer (password) too small");
+    result.key = await _crypto.subtle.importKey("raw", password, id, false, usage);
+    result.salt = "";
+  }
+  if (options.iv)
+    result.iv = options.iv;
+  else if ("ivBits" in algorithm)
+    result.iv = randomBits(_crypto, algorithm.ivBits);
+  return result;
+};
+var getEncryptParams = (algorithm, key, data) => {
+  return [
+    algorithm === "aes-128-ctr" ? { name: "AES-CTR", counter: key.iv, length: 128 } : { name: "AES-CBC", iv: key.iv },
+    key.key,
+    typeof data === "string" ? stringToBuffer(data) : data
+  ];
+};
+var encrypt = async (_crypto, password, options, data) => {
+  const key = await generateKey(_crypto, password, options);
+  const encrypted = await _crypto.subtle.encrypt(...getEncryptParams(options.algorithm, key, data));
+  return { encrypted: new Uint8Array(encrypted), key };
+};
+var decrypt = async (_crypto, password, options, data) => {
+  const key = await generateKey(_crypto, password, options);
+  const decrypted = await _crypto.subtle.decrypt(...getEncryptParams(options.algorithm, key, data));
+  return bufferToString(new Uint8Array(decrypted));
+};
+var hmacWithPassword = async (_crypto, password, options, data) => {
+  const key = await generateKey(_crypto, password, { ...options, hmac: true });
+  const textBuffer = stringToBuffer(data);
+  const signed = await _crypto.subtle.sign({ name: "HMAC" }, key.key, textBuffer);
+  const digest = base64urlEncode(new Uint8Array(signed));
+  return { digest, salt: key.salt };
+};
+var normalizePassword = (password) => {
+  if (typeof password === "string" || password instanceof Uint8Array)
+    return { encryption: password, integrity: password };
+  if ("secret" in password)
+    return { id: password.id, encryption: password.secret, integrity: password.secret };
+  return { id: password.id, encryption: password.encryption, integrity: password.integrity };
+};
+var seal = async (_crypto, object, password, options) => {
+  if (!password)
+    throw new Error("Empty password");
+  const opts = clone(options);
+  const now = Date.now() + (opts.localtimeOffsetMsec || 0);
+  const objectString = JSON.stringify(object);
+  const pass = normalizePassword(password);
+  const { id = "", encryption, integrity } = pass;
+  if (id && !/^\w+$/.test(id))
+    throw new Error("Invalid password id");
+  const { encrypted, key } = await encrypt(_crypto, encryption, opts.encryption, objectString);
+  const encryptedB64 = base64urlEncode(new Uint8Array(encrypted));
+  const iv = base64urlEncode(key.iv);
+  const expiration = opts.ttl ? now + opts.ttl : "";
+  const macBaseString = `${macPrefix}*${id}*${key.salt}*${iv}*${encryptedB64}*${expiration}`;
+  const mac = await hmacWithPassword(_crypto, integrity, opts.integrity, macBaseString);
+  const sealed = `${macBaseString}*${mac.salt}*${mac.digest}`;
+  return sealed;
+};
+var fixedTimeComparison = (a, b) => {
+  let mismatch = a.length === b.length ? 0 : 1;
+  if (mismatch)
+    b = a;
+  for (let i = 0; i < a.length; i += 1)
+    mismatch |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return mismatch === 0;
+};
+var unseal = async (_crypto, sealed, password, options) => {
+  if (!password)
+    throw new Error("Empty password");
+  const opts = clone(options);
+  const now = Date.now() + (opts.localtimeOffsetMsec || 0);
+  const parts = sealed.split("*");
+  if (parts.length !== 8)
+    throw new Error("Incorrect number of sealed components");
+  const prefix = parts[0];
+  let passwordId = parts[1];
+  const encryptionSalt = parts[2];
+  const encryptionIv = parts[3];
+  const encryptedB64 = parts[4];
+  const expiration = parts[5];
+  const hmacSalt = parts[6];
+  const hmac = parts[7];
+  const macBaseString = `${prefix}*${passwordId}*${encryptionSalt}*${encryptionIv}*${encryptedB64}*${expiration}`;
+  if (macPrefix !== prefix)
+    throw new Error("Wrong mac prefix");
+  if (expiration) {
+    if (!/^\d+$/.test(expiration))
+      throw new Error("Invalid expiration");
+    const exp = Number.parseInt(expiration, 10);
+    if (exp <= now - opts.timestampSkewSec * 1e3)
+      throw new Error("Expired seal");
+  }
+  let pass = "";
+  passwordId = passwordId || "default";
+  if (typeof password === "string" || password instanceof Uint8Array)
+    pass = password;
+  else if (passwordId in password) {
+    pass = password[passwordId];
+  } else {
+    throw new Error(`Cannot find password: ${passwordId}`);
+  }
+  pass = normalizePassword(pass);
+  const macOptions = opts.integrity;
+  macOptions.salt = hmacSalt;
+  const mac = await hmacWithPassword(_crypto, pass.integrity, macOptions, macBaseString);
+  if (!fixedTimeComparison(mac.digest, hmac))
+    throw new Error("Bad hmac value");
+  const encrypted = base64urlDecode(encryptedB64);
+  const decryptOptions = opts.encryption;
+  decryptOptions.salt = encryptionSalt;
+  decryptOptions.iv = base64urlDecode(encryptionIv);
+  const decrypted = await decrypt(_crypto, pass.encryption, decryptOptions, encrypted);
+  if (decrypted)
+    return JSON.parse(decrypted);
+  return null;
+};
+
+export { algorithms, base64urlDecode, base64urlEncode, bufferToString, clone, decrypt, defaults, encrypt, generateKey, hmacWithPassword, macFormatVersion, macPrefix, randomBits, seal, stringToBuffer, unseal };
--- a/frontend_admin/.output/server/node_modules/iron-webcrypto/package.json
+++ b/frontend_admin/.output/server/node_modules/iron-webcrypto/package.json
@@ -0,0 +1,72 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "iron-webcrypto",
+  "version": "1.2.1",
+  "description": "a cryptographic utility for sealing-unsealing a JSON object using symmetric key encryption with message integrity verification",
+  "keywords": [
+    "authentication",
+    "data integrity",
+    "encryption",
+    "webcrypto"
+  ],
+  "bugs": {
+    "url": "https://github.com/brc-dd/iron-webcrypto",
+    "email": "brc-dd@hotmail.com"
+  },
+  "repository": "github:brc-dd/iron-webcrypto",
+  "funding": "https://github.com/sponsors/brc-dd",
+  "license": "MIT",
+  "author": "Divyansh Singh <brc-dd@hotmail.com> (https://github.com/brc-dd)",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "import": "./dist/index.js",
+    "require": "./dist/index.cjs"
+  },
+  "main": "dist/index.cjs",
+  "files": [
+    "dist/*"
+  ],
+  "scripts": {
+    "build": "pnpm i && tsup && git add -f dist",
+    "lint": "pnpm build && pnpm lint:only",
+    "lint:only": "lefthook run pre-commit && publint && attw --pack",
+    "test": "pnpm test:node && pnpm test:deno && pnpm test:bun",
+    "test:bun": "bun --cwd=tests/bun test",
+    "test:deno": "deno test tests/deno/index.test.ts --parallel --no-check",
+    "test:node": "tsx --test tests/node/index.test.ts"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.15.3",
+    "@commitlint/cli": "^19.3.0",
+    "@commitlint/config-conventional": "^19.2.2",
+    "@eslint-community/eslint-plugin-eslint-comments": "^4.3.0",
+    "@release-it/conventional-changelog": "^8.0.1",
+    "@types/bun": "^1.1.1",
+    "@types/node": "^20.12.11",
+    "@typescript-eslint/eslint-plugin": "^7.8.0",
+    "@typescript-eslint/parser": "^7.8.0",
+    "eslint": "^8.57.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-config-airbnb-typescript": "^18.0.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-import-resolver-node": "^0.3.9",
+    "eslint-import-resolver-typescript": "^3.6.1",
+    "eslint-plugin-import": "^2.29.1",
+    "eslint-plugin-prettier": "^5.1.3",
+    "eslint-plugin-security": "^3.0.0",
+    "eslint-plugin-unicorn": "^52.0.0",
+    "jsr": "^0.12.4",
+    "lefthook": "^1.6.10",
+    "prettier": "^3.2.5",
+    "prettier-plugin-packagejson": "^2.5.0",
+    "publint": "^0.2.7",
+    "release-it": "^17.2.1",
+    "replace": "^1.2.2",
+    "tsup": "^8.0.2",
+    "tsx": "^4.9.3",
+    "typescript": "^5.4.5"
+  },
+  "packageManager": "pnpm@9.1.0",
+  "runkitExampleFilename": "dist/example.js"
+}
--- a/frontend_admin/.output/server/node_modules/node-mock-http/dist/_polyfill/buffer/node.mjs
+++ b/frontend_admin/.output/server/node_modules/node-mock-http/dist/_polyfill/buffer/node.mjs
@@ -0,0 +1 @@
+export{Buffer}from"node:buffer";
--- a/frontend_admin/.output/server/node_modules/node-mock-http/dist/_polyfill/events/node.mjs
+++ b/frontend_admin/.output/server/node_modules/node-mock-http/dist/_polyfill/events/node.mjs
@@ -0,0 +1 @@
+export{EventEmitter}from"node:events";
--- a/frontend_admin/.output/server/node_modules/node-mock-http/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/node-mock-http/dist/index.mjs
--- a/frontend_admin/.output/server/node_modules/node-mock-http/package.json
+++ b/frontend_admin/.output/server/node_modules/node-mock-http/package.json
@@ -0,0 +1,63 @@
+{
+  "name": "node-mock-http",
+  "version": "1.0.4",
+  "description": "",
+  "repository": "unjs/node-mock-http",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./_polyfill/buffer": {
+      "import": {
+        "node": "./dist/_polyfill/buffer/node.mjs",
+        "default": "./dist/_polyfill/buffer/nodeless.mjs"
+      },
+      "require": {
+        "node": "./dist/_polyfill/buffer/node.cjs",
+        "default": "./dist/_polyfill/buffer/nodeless.cjs"
+      }
+    },
+    "./_polyfill/events": {
+      "import": {
+        "node": "./dist/_polyfill/events/node.mjs",
+        "default": "./dist/_polyfill/events/nodeless.mjs"
+      },
+      "require": {
+        "node": "./dist/_polyfill/events/node.cjs",
+        "default": "./dist/_polyfill/events/nodeless.cjs"
+      }
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild --minify",
+    "dev": "vitest dev --coverage",
+    "lint": "eslint . && prettier -c .",
+    "lint:fix": "automd && eslint . --fix && prettier -w .",
+    "prepack": "pnpm build",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.0.15",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.1",
+    "eslint-config-unjs": "^0.5.0",
+    "jiti": "^2.6.1",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "unbuild": "^3.6.1",
+    "vitest": "^4.0.15"
+  },
+  "packageManager": "pnpm@10.24.0"
+}
--- a/frontend_admin/.output/server/node_modules/perfect-debounce
+++ b/frontend_admin/.output/server/node_modules/perfect-debounce
@@ -0,0 +1 @@
+.nitro/perfect-debounce@2.1.0
--- a/frontend_admin/.output/server/node_modules/radix3/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/radix3/dist/index.mjs
@@ -0,0 +1,262 @@
+const NODE_TYPES = {
+  NORMAL: 0,
+  WILDCARD: 1,
+  PLACEHOLDER: 2
+};
+
+function createRouter(options = {}) {
+  const ctx = {
+    options,
+    rootNode: createRadixNode(),
+    staticRoutesMap: {}
+  };
+  const normalizeTrailingSlash = (p) => options.strictTrailingSlash ? p : p.replace(/\/$/, "") || "/";
+  if (options.routes) {
+    for (const path in options.routes) {
+      insert(ctx, normalizeTrailingSlash(path), options.routes[path]);
+    }
+  }
+  return {
+    ctx,
+    lookup: (path) => lookup(ctx, normalizeTrailingSlash(path)),
+    insert: (path, data) => insert(ctx, normalizeTrailingSlash(path), data),
+    remove: (path) => remove(ctx, normalizeTrailingSlash(path))
+  };
+}
+function lookup(ctx, path) {
+  const staticPathNode = ctx.staticRoutesMap[path];
+  if (staticPathNode) {
+    return staticPathNode.data;
+  }
+  const sections = path.split("/");
+  const params = {};
+  let paramsFound = false;
+  let wildcardNode = null;
+  let node = ctx.rootNode;
+  let wildCardParam = null;
+  for (let i = 0; i < sections.length; i++) {
+    const section = sections[i];
+    if (node.wildcardChildNode !== null) {
+      wildcardNode = node.wildcardChildNode;
+      wildCardParam = sections.slice(i).join("/");
+    }
+    const nextNode = node.children.get(section);
+    if (nextNode === void 0) {
+      if (node && node.placeholderChildren.length > 1) {
+        const remaining = sections.length - i;
+        node = node.placeholderChildren.find((c) => c.maxDepth === remaining) || null;
+      } else {
+        node = node.placeholderChildren[0] || null;
+      }
+      if (!node) {
+        break;
+      }
+      if (node.paramName) {
+        params[node.paramName] = section;
+      }
+      paramsFound = true;
+    } else {
+      node = nextNode;
+    }
+  }
+  if ((node === null || node.data === null) && wildcardNode !== null) {
+    node = wildcardNode;
+    params[node.paramName || "_"] = wildCardParam;
+    paramsFound = true;
+  }
+  if (!node) {
+    return null;
+  }
+  if (paramsFound) {
+    return {
+      ...node.data,
+      params: paramsFound ? params : void 0
+    };
+  }
+  return node.data;
+}
+function insert(ctx, path, data) {
+  let isStaticRoute = true;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  let _unnamedPlaceholderCtr = 0;
+  const matchedNodes = [node];
+  for (const section of sections) {
+    let childNode;
+    if (childNode = node.children.get(section)) {
+      node = childNode;
+    } else {
+      const type = getNodeType(section);
+      childNode = createRadixNode({ type, parent: node });
+      node.children.set(section, childNode);
+      if (type === NODE_TYPES.PLACEHOLDER) {
+        childNode.paramName = section === "*" ? `_${_unnamedPlaceholderCtr++}` : section.slice(1);
+        node.placeholderChildren.push(childNode);
+        isStaticRoute = false;
+      } else if (type === NODE_TYPES.WILDCARD) {
+        node.wildcardChildNode = childNode;
+        childNode.paramName = section.slice(
+          3
+          /* "**:" */
+        ) || "_";
+        isStaticRoute = false;
+      }
+      matchedNodes.push(childNode);
+      node = childNode;
+    }
+  }
+  for (const [depth, node2] of matchedNodes.entries()) {
+    node2.maxDepth = Math.max(matchedNodes.length - depth, node2.maxDepth || 0);
+  }
+  node.data = data;
+  if (isStaticRoute === true) {
+    ctx.staticRoutesMap[path] = node;
+  }
+  return node;
+}
+function remove(ctx, path) {
+  let success = false;
+  const sections = path.split("/");
+  let node = ctx.rootNode;
+  for (const section of sections) {
+    node = node.children.get(section);
+    if (!node) {
+      return success;
+    }
+  }
+  if (node.data) {
+    const lastSection = sections.at(-1) || "";
+    node.data = null;
+    if (Object.keys(node.children).length === 0 && node.parent) {
+      node.parent.children.delete(lastSection);
+      node.parent.wildcardChildNode = null;
+      node.parent.placeholderChildren = [];
+    }
+    success = true;
+  }
+  return success;
+}
+function createRadixNode(options = {}) {
+  return {
+    type: options.type || NODE_TYPES.NORMAL,
+    maxDepth: 0,
+    parent: options.parent || null,
+    children: /* @__PURE__ */ new Map(),
+    data: options.data || null,
+    paramName: options.paramName || null,
+    wildcardChildNode: null,
+    placeholderChildren: []
+  };
+}
+function getNodeType(str) {
+  if (str.startsWith("**")) {
+    return NODE_TYPES.WILDCARD;
+  }
+  if (str[0] === ":" || str === "*") {
+    return NODE_TYPES.PLACEHOLDER;
+  }
+  return NODE_TYPES.NORMAL;
+}
+
+function toRouteMatcher(router) {
+  const table = _routerNodeToTable("", router.ctx.rootNode);
+  return _createMatcher(table, router.ctx.options.strictTrailingSlash);
+}
+function _createMatcher(table, strictTrailingSlash) {
+  return {
+    ctx: { table },
+    matchAll: (path) => _matchRoutes(path, table, strictTrailingSlash)
+  };
+}
+function _createRouteTable() {
+  return {
+    static: /* @__PURE__ */ new Map(),
+    wildcard: /* @__PURE__ */ new Map(),
+    dynamic: /* @__PURE__ */ new Map()
+  };
+}
+function _exportMatcherFromTable(table) {
+  const obj = /* @__PURE__ */ Object.create(null);
+  for (const property in table) {
+    obj[property] = property === "dynamic" ? Object.fromEntries(
+      [...table[property].entries()].map(([key, value]) => [
+        key,
+        _exportMatcherFromTable(value)
+      ])
+    ) : Object.fromEntries(table[property].entries());
+  }
+  return obj;
+}
+function exportMatcher(matcher) {
+  return _exportMatcherFromTable(matcher.ctx.table);
+}
+function _createTableFromExport(matcherExport) {
+  const table = {};
+  for (const property in matcherExport) {
+    table[property] = property === "dynamic" ? new Map(
+      Object.entries(matcherExport[property]).map(([key, value]) => [
+        key,
+        _createTableFromExport(value)
+      ])
+    ) : new Map(
+      Object.entries(matcherExport[property])
+    );
+  }
+  return table;
+}
+function createMatcherFromExport(matcherExport) {
+  return _createMatcher(_createTableFromExport(matcherExport));
+}
+function _matchRoutes(path, table, strictTrailingSlash) {
+  if (strictTrailingSlash !== true && path.endsWith("/")) {
+    path = path.slice(0, -1) || "/";
+  }
+  const matches = [];
+  for (const [key, value] of _sortRoutesMap(table.wildcard)) {
+    if (path === key || path.startsWith(key + "/")) {
+      matches.push(value);
+    }
+  }
+  for (const [key, value] of _sortRoutesMap(table.dynamic)) {
+    if (path.startsWith(key + "/")) {
+      const subPath = "/" + path.slice(key.length).split("/").splice(2).join("/");
+      matches.push(..._matchRoutes(subPath, value));
+    }
+  }
+  const staticMatch = table.static.get(path);
+  if (staticMatch) {
+    matches.push(staticMatch);
+  }
+  return matches.filter(Boolean);
+}
+function _sortRoutesMap(m) {
+  return [...m.entries()].sort((a, b) => a[0].length - b[0].length);
+}
+function _routerNodeToTable(initialPath, initialNode) {
+  const table = _createRouteTable();
+  function _addNode(path, node) {
+    if (path) {
+      if (node.type === NODE_TYPES.NORMAL && !(path.includes("*") || path.includes(":"))) {
+        if (node.data) {
+          table.static.set(path, node.data);
+        }
+      } else if (node.type === NODE_TYPES.WILDCARD) {
+        table.wildcard.set(path.replace("/**", ""), node.data);
+      } else if (node.type === NODE_TYPES.PLACEHOLDER) {
+        const subTable = _routerNodeToTable("", node);
+        if (node.data) {
+          subTable.static.set("/", node.data);
+        }
+        table.dynamic.set(path.replace(/\/\*|\/:\w+/, ""), subTable);
+        return;
+      }
+    }
+    for (const [childPath, child] of node.children.entries()) {
+      _addNode(`${path}/${childPath}`.replace("//", "/"), child);
+    }
+  }
+  _addNode(initialPath, initialNode);
+  return table;
+}
+
+export { NODE_TYPES, createMatcherFromExport, createRouter, exportMatcher, toRouteMatcher };
--- a/frontend_admin/.output/server/node_modules/radix3/package.json
+++ b/frontend_admin/.output/server/node_modules/radix3/package.json
@@ -0,0 +1,52 @@
+{
+  "name": "radix3",
+  "version": "1.1.2",
+  "description": "Lightweight and fast router for JavaScript based on Radix Tree",
+  "repository": "unjs/radix3",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.mjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "bench": "node ./benchmark/direct.mjs",
+    "bench:http": "node ./benchmark/http.mjs",
+    "bench:profile": "0x -o -D benchmark/.profile -- node ./benchmark/direct.mjs",
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint --ext .ts,.mjs . && prettier -c src tests",
+    "lint:fix": "eslint --fix --ext .ts,.mjs . && prettier -w src tests",
+    "playground": "pnpm jiti ./playground.ts",
+    "release": "pnpm test && pnpm build && changelogen --release && git push --follow-tags && npm publish",
+    "test": "pnpm lint && pnpm test:types && vitest run",
+    "test:types": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "0x": "^5.7.0",
+    "@vitest/coverage-v8": "^1.4.0",
+    "autocannon": "^7.15.0",
+    "benchmark": "^2.1.4",
+    "changelogen": "^0.5.5",
+    "eslint": "^8.57.0",
+    "eslint-config-unjs": "^0.2.1",
+    "jiti": "^1.21.0",
+    "listhen": "^1.7.2",
+    "prettier": "^3.2.5",
+    "standard-version": "^9.5.0",
+    "typescript": "^5.4.3",
+    "unbuild": "^2.0.0",
+    "vitest": "^1.4.0"
+  },
+  "packageManager": "pnpm@8.15.5"
+}
--- a/frontend_admin/.output/server/node_modules/uncrypto/dist/crypto.node.mjs
+++ b/frontend_admin/.output/server/node_modules/uncrypto/dist/crypto.node.mjs
@@ -0,0 +1,16 @@
+import nodeCrypto from 'node:crypto';
+
+const subtle = nodeCrypto.webcrypto?.subtle || {};
+const randomUUID = () => {
+  return nodeCrypto.randomUUID();
+};
+const getRandomValues = (array) => {
+  return nodeCrypto.webcrypto.getRandomValues(array);
+};
+const _crypto = {
+  randomUUID,
+  getRandomValues,
+  subtle
+};
+
+export { _crypto as default, getRandomValues, randomUUID, subtle };
--- a/frontend_admin/.output/server/node_modules/uncrypto/package.json
+++ b/frontend_admin/.output/server/node_modules/uncrypto/package.json
@@ -0,0 +1,60 @@
+{
+  "name": "uncrypto",
+  "version": "0.1.3",
+  "description": "Single API for Web Crypto API and Crypto Subtle working in Node.js, Browsers and other runtimes",
+  "repository": "unjs/uncrypto",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "browser": "./dist/crypto.web.mjs",
+      "bun": "./dist/crypto.web.mjs",
+      "deno": "./dist/crypto.web.mjs",
+      "edge-light": "./dist/crypto.web.mjs",
+      "edge-routine": "./dist/crypto.web.mjs",
+      "lagon": "./dist/crypto.web.mjs",
+      "netlify": "./dist/crypto.web.mjs",
+      "react-native": "./dist/crypto.web.mjs",
+      "wintercg": "./dist/crypto.web.mjs",
+      "worker": "./dist/crypto.web.mjs",
+      "workerd": "./dist/crypto.web.mjs",
+      "node": {
+        "require": "./dist/crypto.node.cjs",
+        "import": "./dist/crypto.node.mjs",
+        "types": "./dist/crypto.node.d.ts"
+      },
+      "require": "./dist/crypto.web.cjs",
+      "import": "./dist/crypto.web.mjs",
+      "types": "./dist/crypto.web.d.ts"
+    }
+  },
+  "main": "./dist/crypto.node.cjs",
+  "module": "./dist/crypto.web.mjs",
+  "browser": "./dist/crypto.web.mjs",
+  "types": "./dist/crypto.web.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint --cache --ext .ts,.js,.mjs,.cjs . && prettier -c src test",
+    "lint:fix": "eslint --cache --ext .ts,.js,.mjs,.cjs . --fix && prettier -c src test -w",
+    "prepack": "pnpm run build",
+    "release": "pnpm test && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint && vitest run --coverage"
+  },
+  "devDependencies": {
+    "@types/node": "^20.2.5",
+    "@vitest/coverage-v8": "^0.32.0",
+    "changelogen": "^0.5.3",
+    "eslint": "^8.42.0",
+    "eslint-config-unjs": "^0.2.1",
+    "prettier": "^2.8.8",
+    "typescript": "^5.1.3",
+    "unbuild": "^1.2.1",
+    "vitest": "^0.32.0"
+  },
+  "packageManager": "pnpm@8.6.1"
+}
--- a/frontend_admin/.output/server/node_modules/vue-devtools-stub/dist/index.mjs
+++ b/frontend_admin/.output/server/node_modules/vue-devtools-stub/dist/index.mjs
@@ -0,0 +1,11 @@
+const setupDevtoolsPlugin = () => {
+};
+const isPerformanceSupported = () => false;
+const now = () => Date.now();
+const index = {
+  setupDevtoolsPlugin,
+  isPerformanceSupported,
+  now
+};
+
+export { index as default, isPerformanceSupported, now, setupDevtoolsPlugin };
--- a/frontend_admin/.output/server/node_modules/vue-devtools-stub/package.json
+++ b/frontend_admin/.output/server/node_modules/vue-devtools-stub/package.json
@@ -0,0 +1,41 @@
+{
+  "name": "vue-devtools-stub",
+  "version": "0.1.0",
+  "description": "",
+  "repository": "nuxt-contrib/vue-devtools-stub",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest dev",
+    "lint": "eslint --ext .ts,.js,.mjs,.cjs .",
+    "prepack": "unbuild",
+    "release": "pnpm test && standard-version && git push --follow-tags && pnpm publish",
+    "test": "pnpm lint && vitest run"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@nuxtjs/eslint-config-typescript": "latest",
+    "@vue/devtools-api": "^6.2.1",
+    "@vitest/coverage-c8": "latest",
+    "eslint": "latest",
+    "standard-version": "latest",
+    "typescript": "latest",
+    "unbuild": "latest",
+    "vitest": "latest"
+  },
+  "packageManager": "pnpm@7.8.0"
+}
--- a/frontend_admin/.output/server/node_modules/vue-router
+++ b/frontend_admin/.output/server/node_modules/vue-router
@@ -0,0 +1 @@
+.nitro/vue-router@5.1.0
--- a/frontend_admin/.output/server/node_modules/vue-router/node_modules/@vue/devtools-api
+++ b/frontend_admin/.output/server/node_modules/vue-router/node_modules/@vue/devtools-api
@@ -1 +0,0 @@
-../../../.nitro/@vue/devtools-api@6.6.4