routie dev init since i didn't adhere to any proper guidance up until now

frontend/node_modules/eslint-plugin-vue/dist/utils/casing.js

@@ -0,0 +1,123 @@
+
+//#region lib/utils/casing.ts
+/**
+* Capitalize a string.
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+/**
+* Checks whether the given string has symbols.
+*/
+function hasSymbols(str) {
+	return /[!"#%&'()*+,./:;<=>?@[\\\]^`{|}]/u.exec(str) != null;
+}
+/**
+* Checks whether the given string has uppercase.
+*/
+function hasUpper(str) {
+	return /[A-Z]/u.exec(str) != null;
+}
+/**
+* Convert text to kebab-case
+*/
+function kebabCase(str) {
+	return str.replaceAll("_", "-").replaceAll(/\B([A-Z])/gu, "-$1").toLowerCase();
+}
+/**
+* Checks whether the given string is kebab-case.
+*/
+function isKebabCase(str) {
+	return !hasUpper(str) && !hasSymbols(str) && !str.startsWith("-") && !/_|--|\s/u.test(str);
+}
+/**
+* Convert text to snake_case
+*/
+function snakeCase(str) {
+	return str.replaceAll(/\B([A-Z])/gu, "_$1").replaceAll("-", "_").toLowerCase();
+}
+/**
+* Checks whether the given string is snake_case.
+*/
+function isSnakeCase(str) {
+	return !hasUpper(str) && !hasSymbols(str) && !/-|__|\s/u.test(str);
+}
+/**
+* Convert text to camelCase
+*/
+function camelCase(str) {
+	if (isPascalCase(str)) return str.charAt(0).toLowerCase() + str.slice(1);
+	return str.replaceAll(/[-_](\w)/gu, (_, c) => c ? c.toUpperCase() : "");
+}
+/**
+* Checks whether the given string is camelCase.
+*/
+function isCamelCase(str) {
+	return !hasSymbols(str) && !/^[A-Z]/u.test(str) && !/-|_|\s/u.test(str);
+}
+/**
+* Convert text to PascalCase
+*/
+function pascalCase(str) {
+	return capitalize(camelCase(str));
+}
+/**
+* Checks whether the given string is PascalCase.
+*/
+function isPascalCase(str) {
+	return !hasSymbols(str) && !/^[a-z]/u.test(str) && !/-|_|\s/u.test(str);
+}
+const convertersMap = {
+	"kebab-case": kebabCase,
+	snake_case: snakeCase,
+	camelCase,
+	PascalCase: pascalCase
+};
+const checkersMap = {
+	"kebab-case": isKebabCase,
+	snake_case: isSnakeCase,
+	camelCase: isCamelCase,
+	PascalCase: isPascalCase
+};
+/**
+* Return case checker
+*/
+function getChecker(name) {
+	return checkersMap[name] || isPascalCase;
+}
+/**
+* Return case converter
+*/
+function getConverter(name) {
+	return convertersMap[name] || pascalCase;
+}
+/**
+* Return case exact converter.
+* If the converted result is not in correct case, the original value is returned.
+*/
+function getExactConverter(name) {
+	const converter = getConverter(name);
+	const checker = getChecker(name);
+	return (str) => {
+		const result = converter(str);
+		return checker(result) ? result : str;
+	};
+}
+const allowedCaseOptions = [
+	"camelCase",
+	"kebab-case",
+	"PascalCase"
+];
+
+//#endregion
+exports.allowedCaseOptions = allowedCaseOptions;
+exports.camelCase = camelCase;
+exports.capitalize = capitalize;
+exports.getChecker = getChecker;
+exports.getConverter = getConverter;
+exports.getExactConverter = getExactConverter;
+exports.isCamelCase = isCamelCase;
+exports.isKebabCase = isKebabCase;
+exports.isPascalCase = isPascalCase;
+exports.kebabCase = kebabCase;
+exports.pascalCase = pascalCase;

frontend/node_modules/eslint-plugin-vue/dist/utils/comments.js

@@ -0,0 +1,8 @@
+
+//#region lib/utils/comments.ts
+const isJSDocComment = (node) => node.type === "Block" && node.value.charAt(0) === "*" && node.value.charAt(1) !== "*";
+const isBlockComment = (node) => node.type === "Block" && (node.value.charAt(0) !== "*" || node.value.charAt(1) === "*");
+
+//#endregion
+exports.isBlockComment = isBlockComment;
+exports.isJSDocComment = isJSDocComment;

frontend/node_modules/eslint-plugin-vue/dist/utils/deprecated-html-elements.js

@@ -0,0 +1,41 @@
+
+//#region lib/utils/deprecated-html-elements.json
+var deprecated_html_elements_default = [
+	"acronym",
+	"applet",
+	"basefont",
+	"bgsound",
+	"big",
+	"blink",
+	"center",
+	"dir",
+	"font",
+	"frame",
+	"frameset",
+	"isindex",
+	"keygen",
+	"listing",
+	"marquee",
+	"menuitem",
+	"multicol",
+	"nextid",
+	"nobr",
+	"noembed",
+	"noframes",
+	"param",
+	"plaintext",
+	"rb",
+	"rtc",
+	"spacer",
+	"strike",
+	"tt",
+	"xmp"
+];
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return deprecated_html_elements_default;
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/html-comments.js

@@ -0,0 +1,124 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_index = require('./index.js');
+
+//#region lib/utils/html-comments.ts
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+const COMMENT_DIRECTIVE = /^\s*eslint-(?:en|dis)able/;
+const IE_CONDITIONAL_IF = /^\[if\s+/;
+const IE_CONDITIONAL_ENDIF = /\[endif]$/;
+const TYPE_HTML_COMMENT_OPEN = "HTMLCommentOpen";
+const TYPE_HTML_COMMENT_OPEN_DECORATION = "HTMLCommentOpenDecoration";
+const TYPE_HTML_COMMENT_VALUE = "HTMLCommentValue";
+const TYPE_HTML_COMMENT_CLOSE = "HTMLCommentClose";
+const TYPE_HTML_COMMENT_CLOSE_DECORATION = "HTMLCommentCloseDecoration";
+function isCommentDirective(comment) {
+	return COMMENT_DIRECTIVE.test(comment.value);
+}
+function isIEConditionalComment(comment) {
+	return IE_CONDITIONAL_IF.test(comment.value) || IE_CONDITIONAL_ENDIF.test(comment.value);
+}
+/**
+* Define HTML comment parser
+*/
+function defineParser(sourceCode, config) {
+	config = config || {};
+	const exceptions = config.exceptions || [];
+	/**
+	* Get a open decoration string from comment contents.
+	*/
+	function getOpenDecoration(contents) {
+		let decoration = "";
+		for (const exception of exceptions) {
+			const length = exception.length;
+			let index = 0;
+			while (contents.startsWith(exception, index)) index += length;
+			const exceptionLength = index;
+			if (decoration.length < exceptionLength) decoration = contents.slice(0, exceptionLength);
+		}
+		return decoration;
+	}
+	/**
+	* Get a close decoration string from comment contents.
+	*/
+	function getCloseDecoration(contents) {
+		let decoration = "";
+		for (const exception of exceptions) {
+			const length = exception.length;
+			let index = contents.length;
+			while (contents.endsWith(exception, index)) index -= length;
+			const exceptionLength = contents.length - index;
+			if (decoration.length < exceptionLength) decoration = contents.slice(index);
+		}
+		return decoration;
+	}
+	/**
+	* Parse HTMLComment.
+	*/
+	return function parseHTMLComment(node) {
+		if (node.type !== "HTMLComment") return null;
+		const htmlCommentText = sourceCode.getText(node);
+		if (!htmlCommentText.startsWith("<!--") || !htmlCommentText.endsWith("-->")) return null;
+		let valueText = htmlCommentText.slice(4, -3);
+		const openDecorationText = getOpenDecoration(valueText);
+		valueText = valueText.slice(openDecorationText.length);
+		const firstCharIndex = valueText.search(/\S/);
+		const beforeSpace = firstCharIndex >= 0 ? valueText.slice(0, firstCharIndex) : valueText;
+		valueText = valueText.slice(beforeSpace.length);
+		const closeDecorationText = getCloseDecoration(valueText);
+		if (closeDecorationText) valueText = valueText.slice(0, -closeDecorationText.length);
+		const lastCharIndex = valueText.search(/\S\s*$/);
+		const afterSpace = lastCharIndex >= 0 ? valueText.slice(lastCharIndex + 1) : valueText;
+		if (afterSpace) valueText = valueText.slice(0, -afterSpace.length);
+		let tokenIndex = node.range[0];
+		const createToken = (type, value) => {
+			const range = [tokenIndex, tokenIndex + value.length];
+			tokenIndex = range[1];
+			let loc;
+			return {
+				type,
+				value,
+				range,
+				get loc() {
+					if (loc) return loc;
+					return loc = {
+						start: sourceCode.getLocFromIndex(range[0]),
+						end: sourceCode.getLocFromIndex(range[1])
+					};
+				}
+			};
+		};
+		const open = createToken(TYPE_HTML_COMMENT_OPEN, "<!--");
+		const openDecoration = openDecorationText ? createToken(TYPE_HTML_COMMENT_OPEN_DECORATION, openDecorationText) : null;
+		tokenIndex += beforeSpace.length;
+		const value = valueText ? createToken(TYPE_HTML_COMMENT_VALUE, valueText) : null;
+		tokenIndex += afterSpace.length;
+		return {
+			open,
+			openDecoration,
+			value,
+			closeDecoration: closeDecorationText ? createToken(TYPE_HTML_COMMENT_CLOSE_DECORATION, closeDecorationText) : null,
+			close: createToken(TYPE_HTML_COMMENT_CLOSE, "-->")
+		};
+	};
+}
+/**
+* Define HTML comment visitor
+*/
+function defineVisitor(context, config, visitHTMLComment, visitorOption) {
+	return { Program(node) {
+		visitorOption = visitorOption || {};
+		if (import_utils.default.hasInvalidEOF(node)) return;
+		if (!node.templateBody) return;
+		const parse = defineParser(context.sourceCode, config);
+		for (const comment of node.templateBody.comments) {
+			if (comment.type !== "HTMLComment") continue;
+			if (!visitorOption.includeDirectives && isCommentDirective(comment)) continue;
+			if (isIEConditionalComment(comment)) continue;
+			const tokens = parse(comment);
+			if (tokens) visitHTMLComment(tokens);
+		}
+	} };
+}
+
+//#endregion
+exports.defineVisitor = defineVisitor;

frontend/node_modules/eslint-plugin-vue/dist/utils/html-elements.js

@@ -0,0 +1,130 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/html-elements.json
+var require_html_elements = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"a",
+		"abbr",
+		"address",
+		"area",
+		"article",
+		"aside",
+		"audio",
+		"b",
+		"base",
+		"bdi",
+		"bdo",
+		"blockquote",
+		"body",
+		"br",
+		"button",
+		"canvas",
+		"caption",
+		"cite",
+		"code",
+		"col",
+		"colgroup",
+		"data",
+		"datalist",
+		"dd",
+		"del",
+		"details",
+		"dfn",
+		"dialog",
+		"div",
+		"dl",
+		"dt",
+		"em",
+		"embed",
+		"fencedframe",
+		"fieldset",
+		"figcaption",
+		"figure",
+		"footer",
+		"form",
+		"geolocation",
+		"h1",
+		"h2",
+		"h3",
+		"h4",
+		"h5",
+		"h6",
+		"head",
+		"header",
+		"hgroup",
+		"hr",
+		"html",
+		"i",
+		"iframe",
+		"img",
+		"input",
+		"ins",
+		"kbd",
+		"label",
+		"legend",
+		"li",
+		"link",
+		"main",
+		"map",
+		"mark",
+		"menu",
+		"meta",
+		"meter",
+		"nav",
+		"noscript",
+		"object",
+		"ol",
+		"optgroup",
+		"option",
+		"output",
+		"p",
+		"picture",
+		"pre",
+		"progress",
+		"q",
+		"rp",
+		"rt",
+		"ruby",
+		"s",
+		"samp",
+		"script",
+		"search",
+		"section",
+		"select",
+		"selectedcontent",
+		"slot",
+		"small",
+		"source",
+		"span",
+		"strong",
+		"style",
+		"sub",
+		"summary",
+		"sup",
+		"table",
+		"tbody",
+		"td",
+		"template",
+		"textarea",
+		"tfoot",
+		"th",
+		"thead",
+		"time",
+		"title",
+		"tr",
+		"track",
+		"u",
+		"ul",
+		"var",
+		"video",
+		"wbr"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_html_elements();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/indent-ts.js

@@ -0,0 +1,520 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_index = require('./ts-utils/index.js');
+let _eslint_community_eslint_utils = require("@eslint-community/eslint-utils");
+
+//#region lib/utils/indent-ts.ts
+var import_ts_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+function defineVisitor({ processNodeList, tokenStore, setOffset, copyOffset, processSemicolons, getFirstAndLastTokens }) {
+	/**
+	* Check whether a given token is the first token of:
+	*
+	* - A parameter of TSTypeParameterInstantiation
+	* - An element of TSTupleType
+	*/
+	function isBeginningOfElement(token, belongingNode) {
+		let node = belongingNode;
+		while (node != null && node.parent != null) {
+			const parent = node.parent;
+			if (parent.type === "TSTypeParameterInstantiation") return parent.params.length >= 2 && parent.params.some((param) => getFirstAndLastTokens(param).firstToken.range[0] === token.range[0]);
+			if (parent.type === "TSTupleType") return parent.elementTypes.some((element) => element != null && getFirstAndLastTokens(element).firstToken.range[0] === token.range[0]);
+			node = parent;
+		}
+		return false;
+	}
+	return {
+		["ClassDeclaration[implements], ClassDeclaration[typeParameters], ClassDeclaration[superTypeParameters],ClassExpression[implements], ClassExpression[typeParameters], ClassExpression[superTypeParameters]"](node) {
+			if (node.typeParameters != null) setOffset(tokenStore.getFirstToken(node.typeParameters), 1, tokenStore.getFirstToken(node.id || node));
+			const superTypeArguments = node.superTypeArguments || node.superTypeParameters;
+			if (superTypeArguments != null && node.superClass != null) setOffset(tokenStore.getFirstToken(superTypeArguments), 1, tokenStore.getFirstToken(node.superClass));
+			if (node.implements != null && node.implements.length > 0) {
+				const classToken = tokenStore.getFirstToken(node);
+				const implementsToken = tokenStore.getTokenBefore(node.implements[0]);
+				setOffset(implementsToken, 1, classToken);
+				processNodeList(node.implements, implementsToken, null, 1);
+			}
+		},
+		["TSTypeAliasDeclaration, TSCallSignatureDeclaration, TSConstructSignatureDeclaration, TSImportEqualsDeclaration,TSAbstractMethodDefinition, TSAbstractPropertyDefinition, TSAbstractAccessorProperty, TSEnumMember,TSPropertySignature, TSIndexSignature, TSMethodSignature,ClassProperty, TSAbstractClassProperty"](node) {
+			processSemicolons(node);
+		},
+		"*[type=/^TS/]"(node) {
+			if (!import_ts_utils.default.isTypeNode(node)) return;
+			if (node.parent.type === "TSParenthesizedType") return;
+			let leftToken = tokenStore.getTokenBefore(node);
+			let rightToken = tokenStore.getTokenAfter(node);
+			let firstToken = tokenStore.getFirstToken(node);
+			while (leftToken && rightToken && (0, _eslint_community_eslint_utils.isOpeningParenToken)(leftToken) && (0, _eslint_community_eslint_utils.isClosingParenToken)(rightToken)) {
+				setOffset(firstToken, 1, leftToken);
+				setOffset(rightToken, 0, leftToken);
+				firstToken = leftToken;
+				leftToken = tokenStore.getTokenBefore(leftToken);
+				rightToken = tokenStore.getTokenAfter(rightToken);
+			}
+		},
+		TSTypeAnnotation(node) {
+			const [colonOrArrowToken, secondToken] = tokenStore.getFirstTokens(node, {
+				count: 2,
+				includeComments: false
+			});
+			const baseToken = tokenStore.getFirstToken(node.parent);
+			setOffset([colonOrArrowToken, secondToken], 1, baseToken);
+			const before = tokenStore.getTokenBefore(colonOrArrowToken);
+			if (before && before.value === "?") setOffset(before, 1, baseToken);
+		},
+		"TSAsExpression, TSSatisfiesExpression"(node) {
+			const expressionTokens = getFirstAndLastTokens(node.expression);
+			setOffset([tokenStore.getTokenAfter(expressionTokens.lastToken), getFirstAndLastTokens(node.typeAnnotation).firstToken], 1, expressionTokens.firstToken);
+		},
+		"TSTypeReference, TSInstantiationExpression"(node) {
+			const typeArguments = "typeArguments" in node ? node.typeArguments : node.typeParameters;
+			if (typeArguments) {
+				const firstToken = tokenStore.getFirstToken(node);
+				setOffset(tokenStore.getFirstToken(typeArguments), 1, firstToken);
+			}
+		},
+		"TSTypeParameterInstantiation, TSTypeParameterDeclaration"(node) {
+			processNodeList(node.params, tokenStore.getFirstToken(node), tokenStore.getLastToken(node), 1);
+		},
+		TSTypeAliasDeclaration(node) {
+			const typeToken = tokenStore.getFirstToken(node);
+			const idToken = tokenStore.getFirstToken(node.id);
+			setOffset(idToken, 1, typeToken);
+			let eqToken;
+			if (node.typeParameters) {
+				setOffset(tokenStore.getFirstToken(node.typeParameters), 1, idToken);
+				eqToken = tokenStore.getTokenAfter(node.typeParameters);
+			} else eqToken = tokenStore.getTokenAfter(node.id);
+			const initToken = tokenStore.getTokenAfter(eqToken);
+			setOffset([eqToken, initToken], 1, idToken);
+		},
+		"TSConstructorType, TSFunctionType"(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			let currToken = firstToken;
+			if (node.type === "TSConstructorType") {
+				currToken = tokenStore.getTokenAfter(currToken);
+				setOffset(currToken, 1, firstToken);
+			}
+			if (node.typeParameters) {
+				currToken = tokenStore.getTokenAfter(node.typeParameters);
+				setOffset(currToken, 1, firstToken);
+			}
+			const leftParenToken = currToken;
+			const rightParenToken = tokenStore.getTokenAfter(node.params.at(-1) || leftParenToken, _eslint_community_eslint_utils.isClosingParenToken);
+			processNodeList(node.params, leftParenToken, rightParenToken, 1);
+			setOffset(tokenStore.getTokenAfter(rightParenToken), 1, leftParenToken);
+		},
+		TSTypeLiteral(node) {
+			processNodeList(node.members, tokenStore.getFirstToken(node), tokenStore.getLastToken(node), 1);
+		},
+		TSPropertySignature(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const keyTokens = getFirstAndLastTokens(node.key);
+			let keyLast;
+			if (node.computed) {
+				const closeBracket = tokenStore.getTokenAfter(keyTokens.lastToken);
+				processNodeList([node.key], firstToken, closeBracket, 1);
+				keyLast = closeBracket;
+			} else keyLast = keyTokens.lastToken;
+			if (node.typeAnnotation) {
+				const typeAnnotationToken = tokenStore.getFirstToken(node.typeAnnotation);
+				setOffset([...tokenStore.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, firstToken);
+			} else if (node.optional) setOffset(tokenStore.getLastToken(node), 1, firstToken);
+		},
+		TSIndexSignature(node) {
+			const leftBracketToken = tokenStore.getFirstToken(node);
+			const rightBracketToken = tokenStore.getTokenAfter(node.parameters.at(-1) || leftBracketToken, _eslint_community_eslint_utils.isClosingBracketToken);
+			processNodeList(node.parameters, leftBracketToken, rightBracketToken, 1);
+			const keyLast = rightBracketToken;
+			if (node.typeAnnotation) {
+				const typeAnnotationToken = tokenStore.getFirstToken(node.typeAnnotation);
+				setOffset([...tokenStore.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, leftBracketToken);
+			}
+		},
+		TSArrayType(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			setOffset(tokenStore.getLastTokens(node, {
+				count: 2,
+				includeComments: false
+			}), 0, firstToken);
+		},
+		TSTupleType(node) {
+			processNodeList(node.elementTypes, tokenStore.getFirstToken(node), tokenStore.getLastToken(node), 1);
+		},
+		TSQualifiedName(node) {
+			const objectToken = tokenStore.getFirstToken(node);
+			const dotToken = tokenStore.getTokenBefore(node.right);
+			setOffset([dotToken, tokenStore.getTokenAfter(dotToken)], 1, objectToken);
+		},
+		TSIndexedAccessType(node) {
+			const objectToken = tokenStore.getFirstToken(node);
+			const leftBracketToken = tokenStore.getTokenBefore(node.indexType, _eslint_community_eslint_utils.isOpeningBracketToken);
+			const rightBracketToken = tokenStore.getTokenAfter(node.indexType, _eslint_community_eslint_utils.isClosingBracketToken);
+			setOffset(leftBracketToken, 1, objectToken);
+			processNodeList([node.indexType], leftBracketToken, rightBracketToken, 1);
+		},
+		"TSUnionType, TSIntersectionType"(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const prevToken = tokenStore.getTokenBefore(firstToken);
+			const offset = prevToken == null || prevToken.loc.end.line === firstToken.loc.start.line || isBeginningOfElement(firstToken, node) ? 1 : 0;
+			const typeTokensList = node.types.map(getFirstAndLastTokens);
+			const typeTokens = typeTokensList.shift();
+			if (!typeTokens) return;
+			let lastToken;
+			if (typeTokens.firstToken === firstToken) lastToken = typeTokens.lastToken;
+			else {
+				typeTokensList.unshift(typeTokens);
+				lastToken = firstToken;
+			}
+			for (const typeTokens of typeTokensList) {
+				setOffset(tokenStore.getTokensBetween(lastToken, typeTokens.firstToken), offset, firstToken);
+				setOffset(typeTokens.firstToken, offset, firstToken);
+			}
+		},
+		TSMappedType(node) {
+			const leftBraceToken = tokenStore.getFirstToken(node);
+			const leftBracketToken = tokenStore.getTokenBefore(node.key || node.typeParameter);
+			const rightBracketToken = tokenStore.getTokenAfter(node.nameType || node.constraint || node.typeParameter);
+			setOffset([...tokenStore.getTokensBetween(leftBraceToken, leftBracketToken), leftBracketToken], 1, leftBraceToken);
+			processNodeList([node.key || node.typeParameter, node.nameType], leftBracketToken, rightBracketToken, 1);
+			if (node.constraint) setOffset([...tokenStore.getTokensBetween(node.key, node.constraint), tokenStore.getFirstToken(node.constraint)], 1, tokenStore.getFirstToken(node.key));
+			const rightBraceToken = tokenStore.getLastToken(node);
+			if (node.typeAnnotation) {
+				const typeAnnotationToken = tokenStore.getFirstToken(node.typeAnnotation);
+				setOffset([...tokenStore.getTokensBetween(rightBracketToken, typeAnnotationToken), typeAnnotationToken], 1, leftBraceToken);
+			} else setOffset([...tokenStore.getTokensBetween(rightBracketToken, rightBraceToken)], 1, leftBraceToken);
+			setOffset(rightBraceToken, 0, leftBraceToken);
+		},
+		TSTypeParameter(node) {
+			const [firstToken, ...afterTokens] = tokenStore.getTokens(node);
+			for (const child of [node.constraint, node.default]) {
+				if (!child) continue;
+				const [, ...removeTokens] = tokenStore.getTokens(child);
+				for (const token of removeTokens) {
+					const i = afterTokens.indexOf(token);
+					if (i !== -1) afterTokens.splice(i, 1);
+				}
+			}
+			const secondToken = afterTokens.shift();
+			if (!secondToken) return;
+			setOffset(secondToken, 1, firstToken);
+			if (secondToken.value === "extends") {
+				let prevToken = null;
+				let token = afterTokens.shift();
+				while (token) {
+					if (token.value === "=") break;
+					setOffset(token, 1, secondToken);
+					prevToken = token;
+					token = afterTokens.shift();
+				}
+				while (token) {
+					setOffset(token, 1, prevToken || secondToken);
+					token = afterTokens.shift();
+				}
+			} else setOffset(afterTokens, 1, firstToken);
+		},
+		TSConditionalType(node) {
+			const checkTypeToken = tokenStore.getFirstToken(node);
+			const extendsToken = tokenStore.getTokenAfter(node.checkType);
+			const extendsTypeToken = tokenStore.getFirstToken(node.extendsType);
+			setOffset(extendsToken, 1, checkTypeToken);
+			setOffset(extendsTypeToken, 1, extendsToken);
+			const questionToken = tokenStore.getTokenAfter(node.extendsType, _eslint_community_eslint_utils.isNotClosingParenToken);
+			const consequentToken = tokenStore.getTokenAfter(questionToken);
+			const colonToken = tokenStore.getTokenAfter(node.trueType, _eslint_community_eslint_utils.isNotClosingParenToken);
+			const alternateToken = tokenStore.getTokenAfter(colonToken);
+			let baseNode = node;
+			let parent = baseNode.parent;
+			while (parent && parent.type === "TSConditionalType" && parent.falseType === baseNode) {
+				baseNode = parent;
+				parent = baseNode.parent;
+			}
+			const baseToken = tokenStore.getFirstToken(baseNode);
+			setOffset([questionToken, colonToken], 1, baseToken);
+			setOffset(consequentToken, 1, questionToken);
+			setOffset(alternateToken, 1, colonToken);
+		},
+		TSInterfaceDeclaration(node) {
+			const interfaceToken = tokenStore.getFirstToken(node);
+			setOffset(tokenStore.getFirstToken(node.id), 1, interfaceToken);
+			if (node.typeParameters != null) setOffset(tokenStore.getFirstToken(node.typeParameters), 1, tokenStore.getFirstToken(node.id));
+			if (node.extends != null && node.extends.length > 0) {
+				const extendsToken = tokenStore.getTokenBefore(node.extends[0]);
+				setOffset(extendsToken, 1, interfaceToken);
+				processNodeList(node.extends, extendsToken, null, 1);
+			}
+			setOffset(tokenStore.getFirstToken(node.body), 0, interfaceToken);
+		},
+		"TSInterfaceBody, TSModuleBlock"(node) {
+			processNodeList(node.body, tokenStore.getFirstToken(node), tokenStore.getLastToken(node), 1);
+		},
+		"TSClassImplements, TSInterfaceHeritage"(node) {
+			const typeArguments = node.typeArguments || node.typeParameters;
+			if (typeArguments) setOffset(tokenStore.getFirstToken(typeArguments), 1, tokenStore.getFirstToken(node));
+		},
+		TSEnumDeclaration(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const idTokens = getFirstAndLastTokens(node.id);
+			setOffset(tokenStore.getTokensBetween(firstToken, idTokens.firstToken), 0, firstToken);
+			setOffset(idTokens.firstToken, 1, firstToken);
+			const leftBraceToken = tokenStore.getTokenAfter(idTokens.lastToken);
+			const rightBraceToken = tokenStore.getLastToken(node);
+			setOffset(leftBraceToken, 0, firstToken);
+			if (node.body) return;
+			processNodeList(node.members, leftBraceToken, rightBraceToken, 1);
+		},
+		TSEnumBody(node) {
+			const leftBraceToken = tokenStore.getFirstToken(node);
+			const rightBraceToken = tokenStore.getLastToken(node);
+			processNodeList(node.members, leftBraceToken, rightBraceToken, 1);
+		},
+		TSModuleDeclaration(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const idTokens = getFirstAndLastTokens(node.id);
+			setOffset(tokenStore.getTokensBetween(firstToken, idTokens.firstToken), 0, firstToken);
+			setOffset(idTokens.firstToken, 1, firstToken);
+			if (node.body) {
+				const bodyFirstToken = tokenStore.getFirstToken(node.body);
+				setOffset(bodyFirstToken, (0, _eslint_community_eslint_utils.isOpeningBraceToken)(bodyFirstToken) ? 0 : 1, firstToken);
+			}
+		},
+		TSMethodSignature(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const keyTokens = getFirstAndLastTokens(node.key);
+			let keyLast;
+			if (node.computed) {
+				const closeBracket = tokenStore.getTokenAfter(keyTokens.lastToken);
+				processNodeList([node.key], firstToken, closeBracket, 1);
+				keyLast = closeBracket;
+			} else keyLast = keyTokens.lastToken;
+			const leftParenToken = tokenStore.getTokenAfter(keyLast, _eslint_community_eslint_utils.isOpeningParenToken);
+			setOffset([...tokenStore.getTokensBetween(keyLast, leftParenToken), leftParenToken], 1, firstToken);
+			const rightParenToken = tokenStore.getTokenAfter(node.params.at(-1) || leftParenToken, _eslint_community_eslint_utils.isClosingParenToken);
+			processNodeList(node.params, leftParenToken, rightParenToken, 1);
+			if (node.returnType) {
+				const typeAnnotationToken = tokenStore.getFirstToken(node.returnType);
+				setOffset([...tokenStore.getTokensBetween(keyLast, typeAnnotationToken), typeAnnotationToken], 1, firstToken);
+			}
+		},
+		"TSCallSignatureDeclaration, TSConstructSignatureDeclaration"(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			let currToken = firstToken;
+			if (node.type === "TSConstructSignatureDeclaration") {
+				currToken = tokenStore.getTokenAfter(currToken);
+				setOffset(currToken, 1, firstToken);
+			}
+			if (node.typeParameters) {
+				currToken = tokenStore.getTokenAfter(node.typeParameters);
+				setOffset(currToken, 1, firstToken);
+			}
+			const leftParenToken = currToken;
+			const rightParenToken = tokenStore.getTokenAfter(node.params.at(-1) || leftParenToken, _eslint_community_eslint_utils.isClosingParenToken);
+			processNodeList(node.params, leftParenToken, rightParenToken, 1);
+			if (node.returnType) {
+				const typeAnnotationToken = tokenStore.getFirstToken(node.returnType);
+				setOffset([...tokenStore.getTokensBetween(rightParenToken, typeAnnotationToken), typeAnnotationToken], 1, firstToken);
+			}
+		},
+		"TSDeclareFunction, TSEmptyBodyFunctionExpression"(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			let leftParenToken, bodyBaseToken;
+			if (firstToken.type === "Punctuator") {
+				leftParenToken = firstToken;
+				bodyBaseToken = tokenStore.getFirstToken(node.parent);
+			} else {
+				let nextToken = tokenStore.getTokenAfter(firstToken);
+				let nextTokenOffset = 0;
+				while (nextToken && !(0, _eslint_community_eslint_utils.isOpeningParenToken)(nextToken) && nextToken.value !== "<") {
+					if (nextToken.value === "*" || node.id && nextToken.range[0] === node.id.range[0]) nextTokenOffset = 1;
+					setOffset(nextToken, nextTokenOffset, firstToken);
+					nextToken = tokenStore.getTokenAfter(nextToken);
+				}
+				leftParenToken = nextToken;
+				bodyBaseToken = firstToken;
+			}
+			if (!(0, _eslint_community_eslint_utils.isOpeningParenToken)(leftParenToken) && node.typeParameters) leftParenToken = tokenStore.getTokenAfter(node.typeParameters);
+			const rightParenToken = tokenStore.getTokenAfter(node.params.at(-1) || leftParenToken, _eslint_community_eslint_utils.isClosingParenToken);
+			setOffset(leftParenToken, 1, bodyBaseToken);
+			processNodeList(node.params, leftParenToken, rightParenToken, 1);
+		},
+		"TSTypeOperator, TSTypeQuery, TSInferType"(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			setOffset(tokenStore.getTokenAfter(firstToken), 1, firstToken);
+		},
+		TSTypePredicate(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			setOffset([tokenStore.getTokenAfter(node.parameterName, _eslint_community_eslint_utils.isNotClosingParenToken), node.typeAnnotation && getFirstAndLastTokens(node.typeAnnotation).firstToken], 1, getFirstAndLastTokens(firstToken).firstToken);
+		},
+		["TSAbstractMethodDefinition, TSAbstractPropertyDefinition, TSAbstractAccessorProperty, TSEnumMember,ClassProperty, TSAbstractClassProperty"](node) {
+			const { keyNode, valueNode } = node.type === "TSEnumMember" ? {
+				keyNode: node.id,
+				valueNode: node.initializer
+			} : {
+				keyNode: node.key,
+				valueNode: node.value
+			};
+			const firstToken = tokenStore.getFirstToken(node);
+			const keyTokens = getFirstAndLastTokens(keyNode);
+			const prefixTokens = tokenStore.getTokensBetween(firstToken, keyTokens.firstToken);
+			if (node.computed) prefixTokens.pop();
+			setOffset(prefixTokens, 0, firstToken);
+			let lastKeyToken;
+			if (node.computed) {
+				const leftBracketToken = tokenStore.getTokenBefore(keyTokens.firstToken);
+				const rightBracketToken = lastKeyToken = tokenStore.getTokenAfter(keyTokens.lastToken);
+				setOffset(leftBracketToken, 0, firstToken);
+				processNodeList([keyNode], leftBracketToken, rightBracketToken, 1);
+			} else {
+				setOffset(keyTokens.firstToken, 0, firstToken);
+				lastKeyToken = keyTokens.lastToken;
+			}
+			if (valueNode != null) {
+				const initToken = tokenStore.getFirstToken(valueNode);
+				setOffset([...tokenStore.getTokensBetween(lastKeyToken, initToken), initToken], 1, lastKeyToken);
+			}
+		},
+		"TSOptionalType, TSNonNullExpression, TSJSDocNonNullableType"(node) {
+			setOffset(tokenStore.getLastToken(node), 1, tokenStore.getFirstToken(node));
+		},
+		TSTypeAssertion(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const expressionToken = getFirstAndLastTokens(node.expression).firstToken;
+			processNodeList([node.typeAnnotation], firstToken, tokenStore.getTokenBefore(expressionToken), 1);
+			setOffset(expressionToken, 1, firstToken);
+		},
+		TSImportType(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const leftParenToken = tokenStore.getTokenAfter(firstToken, _eslint_community_eslint_utils.isOpeningParenToken);
+			setOffset(leftParenToken, 1, firstToken);
+			const args = [];
+			if (node.source) args.push(node.source);
+			else args.push(node.argument || node.parameter);
+			if (node.options) args.push(node.options);
+			processNodeList(args, leftParenToken, tokenStore.getTokenAfter(args.at(-1), _eslint_community_eslint_utils.isClosingParenToken), 1);
+			if (node.qualifier) {
+				const dotToken = tokenStore.getTokenBefore(node.qualifier);
+				setOffset([dotToken, tokenStore.getTokenAfter(dotToken)], 1, firstToken);
+			}
+			const typeArguments = "typeArguments" in node ? node.typeArguments : node.typeParameters;
+			if (typeArguments) setOffset(tokenStore.getFirstToken(typeArguments), 1, firstToken);
+		},
+		TSParameterProperty(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const parameterToken = tokenStore.getFirstToken(node.parameter);
+			setOffset([...tokenStore.getTokensBetween(firstToken, parameterToken), parameterToken], 1, firstToken);
+		},
+		TSImportEqualsDeclaration(node) {
+			const importToken = tokenStore.getFirstToken(node);
+			const idTokens = getFirstAndLastTokens(node.id);
+			setOffset(idTokens.firstToken, 1, importToken);
+			setOffset([tokenStore.getTokenAfter(idTokens.lastToken), tokenStore.getFirstToken(node.moduleReference)], 1, idTokens.lastToken);
+		},
+		TSExternalModuleReference(node) {
+			const requireToken = tokenStore.getFirstToken(node);
+			const leftParenToken = tokenStore.getTokenAfter(requireToken, _eslint_community_eslint_utils.isOpeningParenToken);
+			const rightParenToken = tokenStore.getLastToken(node);
+			setOffset(leftParenToken, 1, requireToken);
+			processNodeList([node.expression], leftParenToken, rightParenToken, 1);
+		},
+		TSExportAssignment(node) {
+			const exportNode = tokenStore.getFirstToken(node);
+			const exprTokens = getFirstAndLastTokens(node.expression);
+			setOffset([tokenStore.getTokenBefore(exprTokens.firstToken), exprTokens.firstToken], 1, exportNode);
+		},
+		TSNamedTupleMember(node) {
+			const labelToken = tokenStore.getFirstToken(node);
+			const elementTokens = getFirstAndLastTokens(node.elementType);
+			setOffset([...tokenStore.getTokensBetween(labelToken, elementTokens.firstToken), elementTokens.firstToken], 1, labelToken);
+		},
+		TSRestType(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			setOffset(tokenStore.getTokenAfter(firstToken), 1, firstToken);
+		},
+		TSNamespaceExportDeclaration(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const idToken = tokenStore.getFirstToken(node.id);
+			setOffset([...tokenStore.getTokensBetween(firstToken, idToken), idToken], 1, firstToken);
+		},
+		TSTemplateLiteralType(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const quasiTokens = node.quasis.slice(1).map((n) => tokenStore.getFirstToken(n));
+			const expressionToken = node.quasis.slice(0, -1).map((n) => tokenStore.getTokenAfter(n));
+			setOffset(quasiTokens, 0, firstToken);
+			setOffset(expressionToken, 1, firstToken);
+		},
+		Decorator(node) {
+			const [atToken, secondToken] = tokenStore.getFirstTokens(node, {
+				count: 2,
+				includeComments: false
+			});
+			setOffset(secondToken, 0, atToken);
+			const parent = node.parent;
+			const { decorators, range } = parent;
+			if (!decorators || decorators.length === 0) return;
+			if (decorators[0] === node) if (range[0] === node.range[0]) setOffset(tokenStore.getTokenAfter(decorators.at(-1)), 0, atToken);
+			else copyOffset(atToken, tokenStore.getFirstToken(parent.parent && (parent.parent.type === "ExportDefaultDeclaration" || parent.parent.type === "ExportNamedDeclaration") && node.range[0] < parent.parent.range[0] ? parent.parent : parent));
+			else setOffset(atToken, 0, tokenStore.getFirstToken(decorators[0]));
+		},
+		AccessorProperty(node) {
+			const keyNode = node.key;
+			const valueNode = node.value;
+			const firstToken = tokenStore.getFirstToken(node);
+			const keyTokens = getFirstAndLastTokens(keyNode);
+			const prefixTokens = tokenStore.getTokensBetween(firstToken, keyTokens.firstToken);
+			if (node.computed) prefixTokens.pop();
+			setOffset(prefixTokens, 0, firstToken);
+			let lastKeyToken;
+			if (node.computed) {
+				const leftBracketToken = tokenStore.getTokenBefore(keyTokens.firstToken);
+				const rightBracketToken = lastKeyToken = tokenStore.getTokenAfter(keyTokens.lastToken);
+				setOffset(leftBracketToken, 0, firstToken);
+				processNodeList([keyNode], leftBracketToken, rightBracketToken, 1);
+			} else {
+				setOffset(keyTokens.firstToken, 0, firstToken);
+				lastKeyToken = keyTokens.lastToken;
+			}
+			if (valueNode != null) {
+				const initToken = tokenStore.getFirstToken(valueNode);
+				setOffset([...tokenStore.getTokensBetween(lastKeyToken, initToken), initToken], 1, lastKeyToken);
+			}
+			processSemicolons(node);
+		},
+		ImportAttribute(node) {
+			const firstToken = tokenStore.getFirstToken(node);
+			const keyTokens = getFirstAndLastTokens(node.key);
+			setOffset(tokenStore.getTokensBetween(firstToken, keyTokens.firstToken), 0, firstToken);
+			setOffset(keyTokens.firstToken, 0, firstToken);
+			const initToken = tokenStore.getFirstToken(node.value);
+			setOffset([...tokenStore.getTokensBetween(keyTokens.lastToken, initToken), initToken], 1, keyTokens.lastToken);
+		},
+		TSParenthesizedType(node) {
+			processNodeList([node.typeAnnotation], tokenStore.getFirstToken(node), tokenStore.getLastToken(node), 1);
+		},
+		TSPrivateIdentifier() {},
+		TSAnyKeyword() {},
+		TSBigIntKeyword() {},
+		TSBooleanKeyword() {},
+		TSNeverKeyword() {},
+		TSNullKeyword() {},
+		TSNumberKeyword() {},
+		TSObjectKeyword() {},
+		TSStringKeyword() {},
+		TSSymbolKeyword() {},
+		TSUndefinedKeyword() {},
+		TSUnknownKeyword() {},
+		TSVoidKeyword() {},
+		TSAbstractKeyword() {},
+		TSAsyncKeyword() {},
+		TSPrivateKeyword() {},
+		TSProtectedKeyword() {},
+		TSPublicKeyword() {},
+		TSReadonlyKeyword() {},
+		TSStaticKeyword() {},
+		TSDeclareKeyword() {},
+		TSExportKeyword() {},
+		TSIntrinsicKeyword() {},
+		TSThisType() {},
+		TSLiteralType() {}
+	};
+}
+
+//#endregion
+exports.defineVisitor = defineVisitor;

frontend/node_modules/eslint-plugin-vue/dist/utils/indent-utils.js

@@ -0,0 +1,60 @@
+
+//#region lib/utils/indent-utils.ts
+/**
+* Check whether the given token is a wildcard.
+*/
+function isWildcard(token) {
+	return token != null && token.type === "Punctuator" && token.value === "*";
+}
+/**
+* Check whether the given token is an extends keyword.
+*/
+function isExtendsKeyword(token) {
+	return token != null && token.type === "Keyword" && token.value === "extends";
+}
+/**
+* Check whether the given token is a whitespace.
+*/
+function isNotWhitespace(token) {
+	return token != null && token.type !== "HTMLWhitespace" && (token.type !== "JSXText" || !!token.value.trim());
+}
+/**
+* Check whether the given token is a comment.
+*/
+function isComment(token) {
+	return token != null && (token.type === "Block" || token.type === "Line" || token.type === "Shebang" || typeof token.type === "string" && token.type.endsWith("Comment"));
+}
+/**
+* Check whether the given token is a comment.
+*/
+function isNotComment(token) {
+	return token != null && token.type !== "Block" && token.type !== "Line" && token.type !== "Shebang" && !(typeof token.type === "string" && token.type.endsWith("Comment"));
+}
+/**
+* Check whether the given node is not an empty text node.
+*/
+function isNotEmptyTextNode(node) {
+	return !(node.type === "VText" && node.value.trim() === "");
+}
+/**
+* Check whether the given token is a pipe operator.
+*/
+function isPipeOperator(token) {
+	return token != null && token.type === "Punctuator" && token.value === "|";
+}
+/**
+* Get the last element.
+*/
+function last(xs) {
+	return xs.length === 0 ? void 0 : xs.at(-1);
+}
+
+//#endregion
+exports.isComment = isComment;
+exports.isExtendsKeyword = isExtendsKeyword;
+exports.isNotComment = isNotComment;
+exports.isNotEmptyTextNode = isNotEmptyTextNode;
+exports.isNotWhitespace = isNotWhitespace;
+exports.isPipeOperator = isPipeOperator;
+exports.isWildcard = isWildcard;
+exports.last = last;

frontend/node_modules/eslint-plugin-vue/dist/utils/inline-non-void-elements.js

@@ -0,0 +1,50 @@
+
+//#region lib/utils/inline-non-void-elements.json
+var inline_non_void_elements_default = [
+	"a",
+	"abbr",
+	"audio",
+	"b",
+	"bdi",
+	"bdo",
+	"canvas",
+	"cite",
+	"code",
+	"data",
+	"del",
+	"dfn",
+	"em",
+	"i",
+	"iframe",
+	"ins",
+	"kbd",
+	"label",
+	"map",
+	"mark",
+	"noscript",
+	"object",
+	"output",
+	"picture",
+	"q",
+	"ruby",
+	"s",
+	"samp",
+	"small",
+	"span",
+	"strong",
+	"sub",
+	"sup",
+	"svg",
+	"time",
+	"u",
+	"var",
+	"video"
+];
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return inline_non_void_elements_default;
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/js-reserved.js

@@ -0,0 +1,79 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/js-reserved.json
+var require_js_reserved = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"abstract",
+		"arguments",
+		"await",
+		"boolean",
+		"break",
+		"byte",
+		"case",
+		"catch",
+		"char",
+		"class",
+		"const",
+		"continue",
+		"debugger",
+		"default",
+		"delete",
+		"do",
+		"double",
+		"else",
+		"enum",
+		"eval",
+		"export",
+		"extends",
+		"false",
+		"final",
+		"finally",
+		"float",
+		"for",
+		"function",
+		"goto",
+		"if",
+		"implements",
+		"import",
+		"in",
+		"instanceof",
+		"int",
+		"interface",
+		"let",
+		"long",
+		"native",
+		"new",
+		"null",
+		"package",
+		"private",
+		"protected",
+		"public",
+		"return",
+		"short",
+		"static",
+		"super",
+		"switch",
+		"synchronized",
+		"this",
+		"throw",
+		"throws",
+		"transient",
+		"true",
+		"try",
+		"typeof",
+		"var",
+		"void",
+		"volatile",
+		"while",
+		"with",
+		"yield"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_js_reserved();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/key-aliases.js

@@ -0,0 +1,317 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/key-aliases.json
+var require_key_aliases = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"unidentified",
+		"alt",
+		"alt-graph",
+		"caps-lock",
+		"control",
+		"fn",
+		"fn-lock",
+		"meta",
+		"num-lock",
+		"scroll-lock",
+		"shift",
+		"symbol",
+		"symbol-lock",
+		"hyper",
+		"super",
+		"enter",
+		"tab",
+		"arrow-down",
+		"arrow-left",
+		"arrow-right",
+		"arrow-up",
+		"end",
+		"home",
+		"page-down",
+		"page-up",
+		"backspace",
+		"clear",
+		"copy",
+		"cr-sel",
+		"cut",
+		"delete",
+		"erase-eof",
+		"ex-sel",
+		"insert",
+		"paste",
+		"redo",
+		"undo",
+		"accept",
+		"again",
+		"attn",
+		"cancel",
+		"context-menu",
+		"escape",
+		"execute",
+		"find",
+		"help",
+		"pause",
+		"select",
+		"zoom-in",
+		"zoom-out",
+		"brightness-down",
+		"brightness-up",
+		"eject",
+		"log-off",
+		"power",
+		"print-screen",
+		"hibernate",
+		"standby",
+		"wake-up",
+		"all-candidates",
+		"alphanumeric",
+		"code-input",
+		"compose",
+		"convert",
+		"dead",
+		"final-mode",
+		"group-first",
+		"group-last",
+		"group-next",
+		"group-previous",
+		"mode-change",
+		"next-candidate",
+		"non-convert",
+		"previous-candidate",
+		"process",
+		"single-candidate",
+		"hangul-mode",
+		"hanja-mode",
+		"junja-mode",
+		"eisu",
+		"hankaku",
+		"hiragana",
+		"hiragana-katakana",
+		"kana-mode",
+		"kanji-mode",
+		"katakana",
+		"romaji",
+		"zenkaku",
+		"zenkaku-hankaku",
+		"f1",
+		"f2",
+		"f3",
+		"f4",
+		"f5",
+		"f6",
+		"f7",
+		"f8",
+		"f9",
+		"f10",
+		"f11",
+		"f12",
+		"soft1",
+		"soft2",
+		"soft3",
+		"soft4",
+		"channel-down",
+		"channel-up",
+		"close",
+		"mail-forward",
+		"mail-reply",
+		"mail-send",
+		"media-close",
+		"media-fast-forward",
+		"media-pause",
+		"media-play-pause",
+		"media-record",
+		"media-rewind",
+		"media-stop",
+		"media-track-next",
+		"media-track-previous",
+		"new",
+		"open",
+		"print",
+		"save",
+		"spell-check",
+		"key11",
+		"key12",
+		"audio-balance-left",
+		"audio-balance-right",
+		"audio-bass-boost-down",
+		"audio-bass-boost-toggle",
+		"audio-bass-boost-up",
+		"audio-fader-front",
+		"audio-fader-rear",
+		"audio-surround-mode-next",
+		"audio-treble-down",
+		"audio-treble-up",
+		"audio-volume-down",
+		"audio-volume-up",
+		"audio-volume-mute",
+		"microphone-toggle",
+		"microphone-volume-down",
+		"microphone-volume-up",
+		"microphone-volume-mute",
+		"speech-correction-list",
+		"speech-input-toggle",
+		"launch-application1",
+		"launch-application2",
+		"launch-calendar",
+		"launch-contacts",
+		"launch-mail",
+		"launch-media-player",
+		"launch-music-player",
+		"launch-phone",
+		"launch-screen-saver",
+		"launch-spreadsheet",
+		"launch-web-browser",
+		"launch-web-cam",
+		"launch-word-processor",
+		"browser-back",
+		"browser-favorites",
+		"browser-forward",
+		"browser-home",
+		"browser-refresh",
+		"browser-search",
+		"browser-stop",
+		"app-switch",
+		"call",
+		"camera",
+		"camera-focus",
+		"end-call",
+		"go-back",
+		"go-home",
+		"headset-hook",
+		"last-number-redial",
+		"notification",
+		"manner-mode",
+		"voice-dial",
+		"t-v",
+		"t-v3-d-mode",
+		"t-v-antenna-cable",
+		"t-v-audio-description",
+		"t-v-audio-description-mix-down",
+		"t-v-audio-description-mix-up",
+		"t-v-contents-menu",
+		"t-v-data-service",
+		"t-v-input",
+		"t-v-input-component1",
+		"t-v-input-component2",
+		"t-v-input-composite1",
+		"t-v-input-composite2",
+		"t-v-input-h-d-m-i1",
+		"t-v-input-h-d-m-i2",
+		"t-v-input-h-d-m-i3",
+		"t-v-input-h-d-m-i4",
+		"t-v-input-v-g-a1",
+		"t-v-media-context",
+		"t-v-network",
+		"t-v-number-entry",
+		"t-v-power",
+		"t-v-radio-service",
+		"t-v-satellite",
+		"t-v-satellite-b-s",
+		"t-v-satellite-c-s",
+		"t-v-satellite-toggle",
+		"t-v-terrestrial-analog",
+		"t-v-terrestrial-digital",
+		"t-v-timer",
+		"a-v-r-input",
+		"a-v-r-power",
+		"color-f0-red",
+		"color-f1-green",
+		"color-f2-yellow",
+		"color-f3-blue",
+		"color-f4-grey",
+		"color-f5-brown",
+		"closed-caption-toggle",
+		"dimmer",
+		"display-swap",
+		"d-v-r",
+		"exit",
+		"favorite-clear0",
+		"favorite-clear1",
+		"favorite-clear2",
+		"favorite-clear3",
+		"favorite-recall0",
+		"favorite-recall1",
+		"favorite-recall2",
+		"favorite-recall3",
+		"favorite-store0",
+		"favorite-store1",
+		"favorite-store2",
+		"favorite-store3",
+		"guide",
+		"guide-next-day",
+		"guide-previous-day",
+		"info",
+		"instant-replay",
+		"link",
+		"list-program",
+		"live-content",
+		"lock",
+		"media-apps",
+		"media-last",
+		"media-skip-backward",
+		"media-skip-forward",
+		"media-step-backward",
+		"media-step-forward",
+		"media-top-menu",
+		"navigate-in",
+		"navigate-next",
+		"navigate-out",
+		"navigate-previous",
+		"next-favorite-channel",
+		"next-user-profile",
+		"on-demand",
+		"pairing",
+		"pin-p-down",
+		"pin-p-move",
+		"pin-p-toggle",
+		"pin-p-up",
+		"play-speed-down",
+		"play-speed-reset",
+		"play-speed-up",
+		"random-toggle",
+		"rc-low-battery",
+		"record-speed-next",
+		"rf-bypass",
+		"scan-channels-toggle",
+		"screen-mode-next",
+		"settings",
+		"split-screen-toggle",
+		"s-t-b-input",
+		"s-t-b-power",
+		"subtitle",
+		"teletext",
+		"video-mode-next",
+		"wink",
+		"zoom-toggle",
+		"audio-volume-down",
+		"audio-volume-up",
+		"audio-volume-mute",
+		"browser-back",
+		"browser-forward",
+		"channel-down",
+		"channel-up",
+		"context-menu",
+		"eject",
+		"end",
+		"enter",
+		"home",
+		"media-fast-forward",
+		"media-play",
+		"media-play-pause",
+		"media-record",
+		"media-rewind",
+		"media-stop",
+		"media-next-track",
+		"media-pause",
+		"media-previous-track",
+		"power",
+		"unidentified"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_key_aliases();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/keycode-to-key.js

@@ -0,0 +1,67 @@
+
+//#region lib/utils/keycode-to-key.ts
+var keycode_to_key_default = {
+	8: "backspace",
+	9: "tab",
+	13: "enter",
+	16: "shift",
+	17: "ctrl",
+	18: "alt",
+	19: "pause",
+	20: "caps-lock",
+	27: "escape",
+	32: "space",
+	33: "page-up",
+	34: "page-down",
+	35: "end",
+	36: "home",
+	37: "arrow-left",
+	38: "arrow-up",
+	39: "arrow-right",
+	40: "arrow-down",
+	45: "insert",
+	46: "delete",
+	65: "a",
+	66: "b",
+	67: "c",
+	68: "d",
+	69: "e",
+	70: "f",
+	71: "g",
+	72: "h",
+	73: "i",
+	74: "j",
+	75: "k",
+	76: "l",
+	77: "m",
+	78: "n",
+	79: "o",
+	80: "p",
+	81: "q",
+	82: "r",
+	83: "s",
+	84: "t",
+	85: "u",
+	86: "v",
+	87: "w",
+	88: "x",
+	89: "y",
+	90: "z",
+	112: "f1",
+	113: "f2",
+	114: "f3",
+	115: "f4",
+	116: "f5",
+	117: "f6",
+	118: "f7",
+	119: "f8",
+	120: "f9",
+	121: "f10",
+	122: "f11",
+	123: "f12",
+	144: "num-lock",
+	145: "scroll-lock"
+};
+
+//#endregion
+exports.default = keycode_to_key_default;

frontend/node_modules/eslint-plugin-vue/dist/utils/math-elements.js

@@ -0,0 +1,47 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/math-elements.json
+var require_math_elements = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"math",
+		"maction",
+		"annotation",
+		"annotation-xml",
+		"menclose",
+		"merror",
+		"mfenced",
+		"mfrac",
+		"mi",
+		"mmultiscripts",
+		"mn",
+		"mo",
+		"mover",
+		"mpadded",
+		"mphantom",
+		"mprescripts",
+		"mroot",
+		"mrow",
+		"ms",
+		"semantics",
+		"mspace",
+		"msqrt",
+		"mstyle",
+		"msub",
+		"msup",
+		"msubsup",
+		"mtable",
+		"mtd",
+		"mtext",
+		"mtr",
+		"munder",
+		"munderover"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_math_elements();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/property-references.js

@@ -0,0 +1,399 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_index = require('./index.js');
+let _eslint_community_eslint_utils = require("@eslint-community/eslint-utils");
+
+//#region lib/utils/property-references.ts
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+const ANY = {
+	hasProperty: () => true,
+	allProperties: () => /* @__PURE__ */ new Map(),
+	getNest: () => ANY,
+	getNestNodes: () => []
+};
+const NEVER = {
+	hasProperty: () => false,
+	allProperties: () => /* @__PURE__ */ new Map(),
+	getNest: () => NEVER,
+	getNestNodes: () => []
+};
+function findFunction(context, id) {
+	const calleeVariable = import_utils.default.findVariableByIdentifier(context, id);
+	if (!calleeVariable) return null;
+	if (calleeVariable.defs.length === 1) {
+		const def = calleeVariable.defs[0];
+		if (def.node.type === "FunctionDeclaration") return def.node;
+		if (def.type === "Variable" && def.parent.kind === "const" && def.node.init) {
+			if (def.node.init.type === "FunctionExpression" || def.node.init.type === "ArrowFunctionExpression") return def.node.init;
+			if (def.node.init.type === "Identifier") return findFunction(context, def.node.init);
+		}
+	}
+	return null;
+}
+function definePropertyReferenceExtractor(context, { unknownMemberAsUnreferenced = false, returnAsUnreferenced = false } = {}) {
+	const cacheForExpression = /* @__PURE__ */ new Map();
+	const cacheForPattern = /* @__PURE__ */ new Map();
+	const cacheForFunction = /* @__PURE__ */ new Map();
+	let toRefSet = null;
+	let isFunctionalTemplate = false;
+	const templateBody = context.sourceCode.ast.templateBody;
+	if (templateBody) isFunctionalTemplate = import_utils.default.hasAttribute(templateBody, "functional");
+	function getToRefSet() {
+		if (toRefSet) return toRefSet;
+		const tracker = new _eslint_community_eslint_utils.ReferenceTracker(context.sourceCode.scopeManager.scopes[0]);
+		const toRefNodes = /* @__PURE__ */ new Set();
+		for (const { node } of import_utils.default.iterateReferencesTraceMap(tracker, {
+			[_eslint_community_eslint_utils.ReferenceTracker.ESM]: true,
+			toRef: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true }
+		})) toRefNodes.add(node);
+		const toRefsNodes = /* @__PURE__ */ new Set();
+		for (const { node } of import_utils.default.iterateReferencesTraceMap(tracker, {
+			[_eslint_community_eslint_utils.ReferenceTracker.ESM]: true,
+			toRefs: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true }
+		})) toRefsNodes.add(node);
+		return toRefSet = {
+			toRefNodes,
+			toRefsNodes
+		};
+	}
+	/**
+	* Collects the property references for member expr.
+	*/
+	class PropertyReferencesForMember {
+		node;
+		name;
+		withInTemplate;
+		constructor(node, name, withInTemplate) {
+			this.node = node;
+			this.name = name;
+			this.withInTemplate = withInTemplate;
+		}
+		hasProperty(name) {
+			return name === this.name;
+		}
+		allProperties() {
+			return new Map([[this.name, { nodes: [this.node.property] }]]);
+		}
+		getNest(name) {
+			return name === this.name ? extractFromExpression(this.node, this.withInTemplate) : NEVER;
+		}
+		*getNestNodes(name) {
+			if (name === this.name) yield {
+				type: "expression",
+				node: this.node
+			};
+		}
+	}
+	/**
+	* Collects the property references for object.
+	*/
+	class PropertyReferencesForObject {
+		properties;
+		constructor() {
+			this.properties = Object.create(null);
+		}
+		hasProperty(name) {
+			return Boolean(this.properties[name]);
+		}
+		allProperties() {
+			const result = /* @__PURE__ */ new Map();
+			for (const [name, nodes] of Object.entries(this.properties)) result.set(name, { nodes: nodes.map((node) => node.key) });
+			return result;
+		}
+		getNest(name) {
+			const properties = this.properties[name];
+			return properties ? mergePropertyReferences(properties.map((property) => getNestFromPattern(property.value))) : NEVER;
+		}
+		*getNestNodes(name) {
+			const properties = this.properties[name];
+			if (!properties) return;
+			const values = properties.map((property) => property.value);
+			let node;
+			while (node = values.shift()) if (node.type === "Identifier" || node.type === "MemberExpression" || node.type === "ObjectPattern" || node.type === "ArrayPattern") yield {
+				type: "pattern",
+				node
+			};
+			else if (node.type === "AssignmentPattern") values.unshift(node.left);
+			return properties ? properties.map((p) => p.value) : [];
+		}
+	}
+	function getNestFromPattern(pattern) {
+		if (pattern.type === "ObjectPattern") return extractFromObjectPattern(pattern);
+		if (pattern.type === "Identifier") return extractFromIdentifier(pattern);
+		else if (pattern.type === "AssignmentPattern") return getNestFromPattern(pattern.left);
+		return ANY;
+	}
+	/**
+	* Extract the property references from Expression.
+	*/
+	function extractFromExpression(node, withInTemplate) {
+		const ref = cacheForExpression.get(node);
+		if (ref) return ref;
+		cacheForExpression.set(node, ANY);
+		const result = extractWithoutCache();
+		cacheForExpression.set(node, result);
+		return result;
+		function extractWithoutCache() {
+			const parent = node.parent;
+			switch (parent.type) {
+				case "AssignmentExpression": return !withInTemplate && parent.right === node && parent.operator === "=" ? extractFromPattern(parent.left) : NEVER;
+				case "VariableDeclarator": return !withInTemplate && parent.init === node ? extractFromPattern(parent.id) : NEVER;
+				case "MemberExpression":
+					if (parent.object === node) {
+						const name = import_utils.default.getStaticPropertyName(parent);
+						if (name === "$props" && parent.parent.type === "MemberExpression") {
+							const propName = import_utils.default.getStaticPropertyName(parent.parent);
+							if (!propName) return unknownMemberAsUnreferenced ? NEVER : ANY;
+							return new PropertyReferencesForMember(parent.parent, propName, withInTemplate);
+						} else if (name) return new PropertyReferencesForMember(parent, name, withInTemplate);
+						else return unknownMemberAsUnreferenced ? NEVER : ANY;
+					}
+					return NEVER;
+				case "CallExpression": {
+					const argIndex = parent.arguments.indexOf(node);
+					return !withInTemplate && argIndex !== -1 ? extractFromCall(parent, argIndex) : NEVER;
+				}
+				case "ChainExpression": return extractFromExpression(parent, withInTemplate);
+				case "ArrowFunctionExpression":
+				case "VExpressionContainer":
+				case "Property":
+				case "ArrayExpression": return maybeExternalUsed(parent) ? ANY : NEVER;
+				case "ReturnStatement": if (returnAsUnreferenced) return NEVER;
+				else return maybeExternalUsed(parent) ? ANY : NEVER;
+			}
+			return NEVER;
+		}
+		function maybeExternalUsed(parentTarget) {
+			if (parentTarget.type === "ReturnStatement" || parentTarget.type === "VExpressionContainer") return true;
+			if (parentTarget.type === "ArrayExpression") return maybeExternalUsed(parentTarget.parent);
+			if (parentTarget.type === "Property") return maybeExternalUsed(parentTarget.parent.parent);
+			if (parentTarget.type === "ArrowFunctionExpression") return parentTarget.body === node;
+			return false;
+		}
+	}
+	/**
+	* Extract the property references from one parameter of the function.
+	*/
+	function extractFromPattern(node) {
+		const ref = cacheForPattern.get(node);
+		if (ref) return ref;
+		cacheForPattern.set(node, ANY);
+		const result = extractWithoutCache();
+		cacheForPattern.set(node, result);
+		return result;
+		function extractWithoutCache() {
+			while (node.type === "AssignmentPattern") node = node.left;
+			if (node.type === "RestElement" || node.type === "ArrayPattern") return NEVER;
+			if (node.type === "ObjectPattern") return extractFromObjectPattern(node);
+			if (node.type === "Identifier") return extractFromIdentifier(node);
+			return NEVER;
+		}
+	}
+	/**
+	* Extract the property references from ObjectPattern.
+	*/
+	function extractFromObjectPattern(node) {
+		const refs = new PropertyReferencesForObject();
+		for (const prop of node.properties) if (prop.type === "Property") {
+			const name = import_utils.default.getStaticPropertyName(prop);
+			if (name) (refs.properties[name] || (refs.properties[name] = [])).push(prop);
+			else return ANY;
+		} else return ANY;
+		return refs;
+	}
+	/**
+	* Extract the property references from id.
+	*/
+	function extractFromIdentifier(node) {
+		const variable = import_utils.default.findVariableByIdentifier(context, node);
+		if (!variable) return NEVER;
+		return mergePropertyReferences(variable.references.map((reference) => {
+			const id = reference.identifier;
+			return extractFromExpression(id, false);
+		}));
+	}
+	/**
+	* Extract the property references from call.
+	*/
+	function extractFromCall(node, argIndex) {
+		if (node.callee.type !== "Identifier") return {
+			hasProperty(_name, options) {
+				return Boolean(options && options.unknownCallAsAny);
+			},
+			allProperties: () => /* @__PURE__ */ new Map(),
+			getNest: () => ANY,
+			getNestNodes: () => []
+		};
+		const fnNode = findFunction(context, node.callee);
+		if (!fnNode) {
+			if (argIndex === 0) {
+				if (getToRefSet().toRefNodes.has(node)) return extractFromToRef(node);
+				else if (getToRefSet().toRefsNodes.has(node)) return extractFromToRefs(node);
+			}
+			return {
+				hasProperty(_name, options) {
+					return Boolean(options && options.unknownCallAsAny);
+				},
+				allProperties: () => /* @__PURE__ */ new Map(),
+				getNest: () => ANY,
+				getNestNodes: () => []
+			};
+		}
+		return extractFromFunctionParam(fnNode, argIndex);
+	}
+	/**
+	* Extract the property references from function param.
+	*/
+	function extractFromFunctionParam(node, argIndex) {
+		let cacheForIndexes = cacheForFunction.get(node);
+		if (!cacheForIndexes) {
+			cacheForIndexes = /* @__PURE__ */ new Map();
+			cacheForFunction.set(node, cacheForIndexes);
+		}
+		const ref = cacheForIndexes.get(argIndex);
+		if (ref) return ref;
+		cacheForIndexes.set(argIndex, NEVER);
+		const arg = node.params[argIndex];
+		if (!arg) return NEVER;
+		const result = extractFromPattern(arg);
+		cacheForIndexes.set(argIndex, result);
+		return result;
+	}
+	/**
+	* Extract the property references from path.
+	*/
+	function extractFromPath(pathString, node) {
+		return extractFromSegments(pathString.split("."));
+		function extractFromSegments(segments) {
+			if (segments.length === 0) return ANY;
+			const segmentName = segments[0];
+			return {
+				hasProperty: (name) => name === segmentName,
+				allProperties: () => new Map([[segmentName, { nodes: [node] }]]),
+				getNest: (name) => name === segmentName ? extractFromSegments(segments.slice(1)) : NEVER,
+				getNestNodes: () => []
+			};
+		}
+	}
+	/**
+	* Extract the property references from name literal.
+	*/
+	function extractFromNameLiteral(node) {
+		const referenceName = node.type === "Literal" || node.type === "TemplateLiteral" ? import_utils.default.getStringLiteralValue(node) : null;
+		return referenceName ? {
+			hasProperty: (name) => name === referenceName,
+			allProperties: () => new Map([[referenceName, { nodes: [node] }]]),
+			getNest: (name) => name === referenceName ? ANY : NEVER,
+			getNestNodes: () => []
+		} : NEVER;
+	}
+	/**
+	* Extract the property references from name.
+	*/
+	function extractFromName(referenceName, nameNode, getNest) {
+		return {
+			hasProperty: (name) => name === referenceName,
+			allProperties: () => new Map([[referenceName, { nodes: [nameNode] }]]),
+			getNest: (name) => name === referenceName ? getNest ? getNest() : ANY : NEVER,
+			getNestNodes: () => []
+		};
+	}
+	/**
+	* Extract the property references from toRef call.
+	*/
+	function extractFromToRef(node) {
+		const nameNode = node.arguments[1];
+		const refName = nameNode && (nameNode.type === "Literal" || nameNode.type === "TemplateLiteral") ? import_utils.default.getStringLiteralValue(nameNode) : null;
+		if (!refName) return ANY;
+		return extractFromName(refName, nameNode, () => extractFromExpression(node, false).getNest("value"));
+	}
+	/**
+	* Extract the property references from toRefs call.
+	*/
+	function extractFromToRefs(node) {
+		const base = extractFromExpression(node, false);
+		return {
+			hasProperty: (name, option) => base.hasProperty(name, option),
+			allProperties: () => base.allProperties(),
+			getNest: (name) => base.getNest(name).getNest("value"),
+			getNestNodes: (name) => base.getNest(name).getNestNodes("value")
+		};
+	}
+	/**
+	* Extract the property references from VExpressionContainer.
+	*/
+	function extractFromVExpressionContainer(node, options) {
+		const ignoreGlobals = options && options.ignoreGlobals;
+		let ignoreRef = () => false;
+		if (ignoreGlobals) {
+			const globalScope = context.sourceCode.scopeManager.globalScope || context.sourceCode.scopeManager.scopes[0];
+			ignoreRef = (name) => globalScope.set.has(name);
+		}
+		const references = [];
+		for (const id of node.references.filter((ref) => ref.variable == null).map((ref) => ref.id)) {
+			if (ignoreRef(id.name)) continue;
+			if (isFunctionalTemplate) {
+				if (id.name === "props") references.push(extractFromExpression(id, true));
+			} else {
+				const referenceId = id.name === "$props" && id.parent.type === "MemberExpression" && id.parent.property.type === "Identifier" ? id.parent.property : id;
+				references.push(extractFromName(referenceId.name, referenceId, () => extractFromExpression(referenceId, true)));
+			}
+		}
+		return mergePropertyReferences(references);
+	}
+	/**
+	* Extract the property references from StyleVariablesContext.
+	*/
+	function extractFromStyleVariablesContext(ctx) {
+		const references = [];
+		for (const { id } of ctx.references) references.push(extractFromName(id.name, id, () => extractFromExpression(id, true)));
+		return mergePropertyReferences(references);
+	}
+	return {
+		extractFromExpression,
+		extractFromPattern,
+		extractFromFunctionParam,
+		extractFromPath,
+		extractFromName,
+		extractFromNameLiteral,
+		extractFromVExpressionContainer,
+		extractFromStyleVariablesContext
+	};
+}
+function mergePropertyReferences(references) {
+	if (references.length === 0) return NEVER;
+	if (references.length === 1) return references[0];
+	return new PropertyReferencesForMerge(references);
+}
+/**
+* Collects the property references for merge.
+*/
+var PropertyReferencesForMerge = class {
+	references;
+	constructor(references) {
+		this.references = references;
+	}
+	hasProperty(name, option) {
+		return this.references.some((ref) => ref.hasProperty(name, option));
+	}
+	allProperties() {
+		const result = /* @__PURE__ */ new Map();
+		for (const reference of this.references) for (const [name, { nodes }] of reference.allProperties()) {
+			const r = result.get(name);
+			if (r) r.nodes = [...new Set([...r.nodes, ...nodes])];
+			else result.set(name, { nodes: [...nodes] });
+		}
+		return result;
+	}
+	getNest(name) {
+		const nest = [];
+		for (const ref of this.references) if (ref.hasProperty(name)) nest.push(ref.getNest(name));
+		return mergePropertyReferences(nest);
+	}
+	*getNestNodes(name) {
+		for (const ref of this.references) if (ref.hasProperty(name)) yield* ref.getNestNodes(name);
+	}
+};
+
+//#endregion
+exports.definePropertyReferenceExtractor = definePropertyReferenceExtractor;
+exports.mergePropertyReferences = mergePropertyReferences;

frontend/node_modules/eslint-plugin-vue/dist/utils/ref-object-references.js

@@ -0,0 +1,315 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_index = require('./index.js');
+const require_property_references = require('./property-references.js');
+let _eslint_community_eslint_utils = require("@eslint-community/eslint-utils");
+
+//#region lib/utils/ref-object-references.ts
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+const REF_MACROS = [
+	"$ref",
+	"$computed",
+	"$shallowRef",
+	"$customRef",
+	"$toRef",
+	"$"
+];
+const cacheForRefObjectReferences = /* @__PURE__ */ new WeakMap();
+const cacheForReactiveVariableReferences = /* @__PURE__ */ new WeakMap();
+/**
+* Iterate the call expressions that define the ref object.
+*/
+function* iterateDefineRefs(globalScope) {
+	const tracker = new _eslint_community_eslint_utils.ReferenceTracker(globalScope);
+	for (const { node, path } of import_utils.default.iterateReferencesTraceMap(tracker, {
+		ref: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true },
+		computed: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true },
+		toRef: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true },
+		customRef: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true },
+		shallowRef: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true },
+		toRefs: { [_eslint_community_eslint_utils.ReferenceTracker.CALL]: true }
+	})) yield {
+		node,
+		name: path.at(-1)
+	};
+}
+/**
+* Iterate the call expressions that defineModel() macro.
+*/
+function* iterateDefineModels(globalScope) {
+	for (const { identifier } of iterateMacroReferences()) if (identifier.parent.type === "CallExpression" && identifier.parent.callee === identifier) yield { node: identifier.parent };
+	/**
+	* Iterate macro reference.
+	*/
+	function* iterateMacroReferences() {
+		const variable = globalScope.set.get("defineModel");
+		if (variable && variable.defs.length === 0) yield* variable.references;
+		for (const ref of globalScope.through) if (ref.identifier.name === "defineModel") yield ref;
+	}
+}
+/**
+* Iterate the call expressions that define the reactive variables.
+*/
+function* iterateDefineReactiveVariables(globalScope) {
+	for (const { identifier } of iterateRefMacroReferences()) if (identifier.parent.type === "CallExpression" && identifier.parent.callee === identifier) yield {
+		node: identifier.parent,
+		name: identifier.name
+	};
+	/**
+	* Iterate ref macro reference.
+	*/
+	function* iterateRefMacroReferences() {
+		yield* REF_MACROS.map((m) => globalScope.set.get(m)).filter(import_utils.default.isDef).flatMap((v) => v.references);
+		for (const ref of globalScope.through) if (REF_MACROS.includes(ref.identifier.name)) yield ref;
+	}
+}
+/**
+*  Iterate the call expressions that the escape hint values.
+*/
+function* iterateEscapeHintValueRefs(globalScope) {
+	for (const { identifier } of iterateEscapeHintReferences()) if (identifier.parent.type === "CallExpression" && identifier.parent.callee === identifier) yield identifier.parent;
+	/**
+	* Iterate escape hint reference.
+	*/
+	function* iterateEscapeHintReferences() {
+		const escapeHint = globalScope.set.get("$$");
+		if (escapeHint) yield* escapeHint.references;
+		for (const ref of globalScope.through) if (ref.identifier.name === "$$") yield ref;
+	}
+}
+/**
+* Extract identifier from given pattern node.
+*/
+function* extractIdentifier(node) {
+	switch (node.type) {
+		case "Identifier":
+			yield node;
+			break;
+		case "ObjectPattern":
+			for (const property of node.properties) if (property.type === "Property") yield* extractIdentifier(property.value);
+			else if (property.type === "RestElement") yield* extractIdentifier(property);
+			break;
+		case "ArrayPattern":
+			for (const element of node.elements) if (element) yield* extractIdentifier(element);
+			break;
+		case "AssignmentPattern":
+			yield* extractIdentifier(node.left);
+			break;
+		case "RestElement":
+			yield* extractIdentifier(node.argument);
+			break;
+		case "MemberExpression": break;
+	}
+}
+/**
+* Iterate references of the given identifier.
+*/
+function* iterateIdentifierReferences(id, globalScope) {
+	const variable = (0, _eslint_community_eslint_utils.findVariable)(globalScope, id);
+	if (!variable) return;
+	for (const reference of variable.references) yield reference;
+}
+function getGlobalScope(context) {
+	const sourceCode = context.sourceCode;
+	return sourceCode.scopeManager.globalScope || sourceCode.scopeManager.scopes[0];
+}
+var RefObjectReferenceExtractor = class {
+	context;
+	references = /* @__PURE__ */ new Map();
+	_processedIds = /* @__PURE__ */ new Set();
+	constructor(context) {
+		this.context = context;
+	}
+	get(node) {
+		return this.references.get(node) || null;
+	}
+	processDefineRef(node, method) {
+		const parent = node.parent;
+		let pattern = null;
+		if (parent.type === "VariableDeclarator") pattern = parent.id;
+		else if (parent.type === "AssignmentExpression" && parent.operator === "=") pattern = parent.left;
+		else {
+			if (method !== "toRefs") this.references.set(node, {
+				type: "expression",
+				node,
+				method,
+				define: node,
+				defineChain: [node]
+			});
+			return;
+		}
+		const ctx = {
+			method,
+			define: node,
+			defineChain: [node]
+		};
+		if (method === "toRefs") {
+			const propertyReferences = require_property_references.definePropertyReferenceExtractor(this.context).extractFromPattern(pattern);
+			for (const name of propertyReferences.allProperties().keys()) for (const nest of propertyReferences.getNestNodes(name)) if (nest.type === "expression") this.processMemberExpression(nest.node, ctx);
+			else if (nest.type === "pattern") this.processPattern(nest.node, ctx);
+		} else this.processPattern(pattern, ctx);
+	}
+	processDefineModel(node) {
+		const parent = node.parent;
+		let pattern = null;
+		if (parent.type === "VariableDeclarator") pattern = parent.id;
+		else if (parent.type === "AssignmentExpression" && parent.operator === "=") pattern = parent.left;
+		else return;
+		const ctx = {
+			method: "defineModel",
+			define: node,
+			defineChain: [node]
+		};
+		if (pattern.type === "ArrayPattern" && pattern.elements[0]) pattern = pattern.elements[0];
+		this.processPattern(pattern, ctx);
+	}
+	processExpression(node, ctx) {
+		const parent = node.parent;
+		if (parent.type === "AssignmentExpression") {
+			if (parent.operator === "=" && parent.right === node) {
+				this.processPattern(parent.left, {
+					...ctx,
+					defineChain: [node, ...ctx.defineChain]
+				});
+				return true;
+			}
+		} else if (parent.type === "VariableDeclarator" && parent.init === node) {
+			this.processPattern(parent.id, {
+				...ctx,
+				defineChain: [node, ...ctx.defineChain]
+			});
+			return true;
+		}
+		return false;
+	}
+	processMemberExpression(node, ctx) {
+		if (this.processExpression(node, ctx)) return;
+		this.references.set(node, {
+			type: "expression",
+			node,
+			...ctx
+		});
+	}
+	processPattern(node, ctx) {
+		switch (node.type) {
+			case "Identifier":
+				this.processIdentifierPattern(node, ctx);
+				break;
+			case "ArrayPattern":
+			case "RestElement":
+			case "MemberExpression": return;
+			case "ObjectPattern":
+				this.references.set(node, {
+					type: "pattern",
+					node,
+					...ctx
+				});
+				return;
+			case "AssignmentPattern":
+				this.processPattern(node.left, ctx);
+				return;
+		}
+	}
+	processIdentifierPattern(node, ctx) {
+		if (this._processedIds.has(node)) return;
+		this._processedIds.add(node);
+		for (const reference of iterateIdentifierReferences(node, getGlobalScope(this.context))) {
+			const def = reference.resolved && reference.resolved.defs.length === 1 && reference.resolved.defs[0].type === "Variable" ? reference.resolved.defs[0] : null;
+			if (def && def.name === reference.identifier) continue;
+			if (reference.isRead() && this.processExpression(reference.identifier, ctx)) continue;
+			this.references.set(reference.identifier, {
+				type: reference.isWrite() ? "pattern" : "expression",
+				node: reference.identifier,
+				variableDeclarator: def ? def.node : null,
+				variableDeclaration: def ? def.parent : null,
+				...ctx
+			});
+		}
+	}
+};
+/**
+* Extracts references of all ref objects.
+* @param context The rule context.
+*/
+function extractRefObjectReferences(context) {
+	const sourceCode = context.sourceCode;
+	const cachedReferences = cacheForRefObjectReferences.get(sourceCode.ast);
+	if (cachedReferences) return cachedReferences;
+	const references = new RefObjectReferenceExtractor(context);
+	const globalScope = getGlobalScope(context);
+	for (const { node, name } of iterateDefineRefs(globalScope)) references.processDefineRef(node, name);
+	for (const { node } of iterateDefineModels(globalScope)) references.processDefineModel(node);
+	cacheForRefObjectReferences.set(sourceCode.ast, references);
+	return references;
+}
+var ReactiveVariableReferenceExtractor = class {
+	context;
+	references;
+	_processedIds;
+	_escapeHintValueRefs;
+	constructor(context) {
+		this.context = context;
+		this.references = /* @__PURE__ */ new Map();
+		this._processedIds = /* @__PURE__ */ new Set();
+		this._escapeHintValueRefs = new Set(iterateEscapeHintValueRefs(getGlobalScope(context)));
+	}
+	get(node) {
+		return this.references.get(node) || null;
+	}
+	processDefineReactiveVariable(node, method) {
+		const parent = node.parent;
+		if (parent.type !== "VariableDeclarator") return;
+		const pattern = parent.id;
+		if (method === "$") for (const id of extractIdentifier(pattern)) this.processIdentifierPattern(id, method, node);
+		else if (pattern.type === "Identifier") this.processIdentifierPattern(pattern, method, node);
+	}
+	processIdentifierPattern(node, method, define) {
+		if (this._processedIds.has(node)) return;
+		this._processedIds.add(node);
+		for (const reference of iterateIdentifierReferences(node, getGlobalScope(this.context))) {
+			const def = reference.resolved && reference.resolved.defs.length === 1 && reference.resolved.defs[0].type === "Variable" ? reference.resolved.defs[0] : null;
+			if (!def || def.name === reference.identifier) continue;
+			this.references.set(reference.identifier, {
+				node: reference.identifier,
+				escape: this.withinEscapeHint(reference.identifier),
+				method,
+				define,
+				variableDeclaration: def.parent
+			});
+		}
+	}
+	/**
+	* Checks whether the given identifier node within the escape hints (`$$()`) or not.
+	*/
+	withinEscapeHint(node) {
+		let target = node;
+		let parent = target.parent;
+		while (parent) {
+			if (parent.type === "CallExpression") {
+				if (parent.arguments.includes(target) && this._escapeHintValueRefs.has(parent)) return true;
+				return false;
+			}
+			if (parent.type === "Property" && parent.value === target || parent.type === "ObjectExpression" && parent.properties.includes(target) || parent.type === "ArrayExpression" || parent.type === "SpreadElement") {
+				target = parent;
+				parent = target.parent;
+			} else return false;
+		}
+		return false;
+	}
+};
+/**
+* Extracts references of all reactive variables.
+*/
+function extractReactiveVariableReferences(context) {
+	const sourceCode = context.sourceCode;
+	const cachedReferences = cacheForReactiveVariableReferences.get(sourceCode.ast);
+	if (cachedReferences) return cachedReferences;
+	const references = new ReactiveVariableReferenceExtractor(context);
+	for (const { node, name } of iterateDefineReactiveVariables(getGlobalScope(context))) references.processDefineReactiveVariable(node, name);
+	cacheForReactiveVariableReferences.set(sourceCode.ast, references);
+	return references;
+}
+
+//#endregion
+exports.extractReactiveVariableReferences = extractReactiveVariableReferences;
+exports.extractRefObjectReferences = extractRefObjectReferences;
+exports.iterateDefineRefs = iterateDefineRefs;

frontend/node_modules/eslint-plugin-vue/dist/utils/regexp.js

@@ -0,0 +1,45 @@
+
+//#region lib/utils/regexp.ts
+const RE_REGEXP_CHAR = /[\\^$.*+?()[\]{}|]/gu;
+const RE_HAS_REGEXP_CHAR = new RegExp(RE_REGEXP_CHAR.source);
+const RE_REGEXP_STR = /^\/(.+)\/(.*)$/u;
+/**
+* Escapes the `RegExp` special characters "^", "$", "\", ".", "*", "+",
+* "?", "(", ")", "[", "]", "{", "}", and "|" in `string`.
+*/
+function escape(string) {
+	return string && RE_HAS_REGEXP_CHAR.test(string) ? string.replaceAll(RE_REGEXP_CHAR, String.raw`\$&`) : string;
+}
+/**
+* Convert a string to the `RegExp`.
+* Normal strings (e.g. `"foo"`) is converted to `/^foo$/` of `RegExp`.
+* Strings like `"/^foo/i"` are converted to `/^foo/i` of `RegExp`.
+*/
+function toRegExp(string, flags = {}) {
+	const parts = RE_REGEXP_STR.exec(string);
+	const { add: forceAddFlags = "", remove: forceRemoveFlags = "" } = typeof flags === "object" ? flags : {};
+	if (parts) return new RegExp(parts[1], parts[2].replaceAll(new RegExp(`[${forceAddFlags}${forceRemoveFlags}]`, "g"), "") + forceAddFlags);
+	return new RegExp(`^${escape(string)}$`, forceAddFlags);
+}
+/**
+* Checks whether given string is regexp string
+*/
+function isRegExp(string) {
+	return RE_REGEXP_STR.test(string);
+}
+/**
+* Converts an array of strings or regular expression strings to a singular function to match any of them.
+* This function converts each string to a `RegExp` and returns a function that checks all of them.
+*/
+function toRegExpGroupMatcher(patterns = []) {
+	if (patterns.length === 0) return () => false;
+	const regexps = patterns.map((pattern) => toRegExp(pattern, { remove: "g" }));
+	if (regexps.length === 1) return (...toCheck) => toCheck.some((str) => regexps[0].test(str));
+	return (...toCheck) => regexps.some((regexp) => toCheck.some((str) => regexp.test(str)));
+}
+
+//#endregion
+exports.escape = escape;
+exports.isRegExp = isRegExp;
+exports.toRegExp = toRegExp;
+exports.toRegExpGroupMatcher = toRegExpGroupMatcher;

frontend/node_modules/eslint-plugin-vue/dist/utils/scope.js

@@ -0,0 +1,34 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/scope.js
+var require_scope = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = { getScope };
+	/**
+	* Gets the scope for the current node
+	* @param {RuleContext} context The rule context
+	* @param {ESNode} currentNode The node to get the scope of
+	* @returns { import('eslint').Scope.Scope } The scope information for this node
+	*/
+	function getScope(context, currentNode) {
+		const inner = currentNode.type !== "Program";
+		const scopeManager = context.sourceCode.scopeManager;
+		/** @type {ESNode | null} */
+		let node = currentNode;
+		for (; node; node = node.parent) {
+			const scope = scopeManager.acquire(node, inner);
+			if (scope) {
+				if (scope.type === "function-expression-name") return scope.childScopes[0];
+				return scope;
+			}
+		}
+		return scopeManager.scopes[0];
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_scope();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/selector.js

@@ -0,0 +1,330 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_index = require('./index.js');
+let postcss_selector_parser = require("postcss-selector-parser");
+postcss_selector_parser = require_runtime.__toESM(postcss_selector_parser);
+let nth_check = require("nth-check");
+nth_check = require_runtime.__toESM(nth_check);
+
+//#region lib/utils/selector.ts
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+/**
+* Parses CSS selectors and returns an object with a function that tests VElement.
+*/
+function parseSelector(selector, context) {
+	let astSelector;
+	try {
+		astSelector = (0, postcss_selector_parser.default)().astSync(selector);
+	} catch {
+		context.report({
+			loc: {
+				line: 0,
+				column: 0
+			},
+			message: `Cannot parse selector: ${selector}.`
+		});
+		return { test: () => false };
+	}
+	try {
+		const test = selectorsToVElementMatcher(astSelector.nodes);
+		return { test(element) {
+			return test(element, null);
+		} };
+	} catch (error) {
+		if (error instanceof SelectorError) {
+			context.report({
+				loc: {
+					line: 0,
+					column: 0
+				},
+				message: error.message
+			});
+			return { test: () => false };
+		}
+		throw error;
+	}
+}
+var SelectorError = class extends Error {};
+/**
+* Convert nodes to VElementMatcher
+*/
+function selectorsToVElementMatcher(selectorNodes) {
+	const selectors = selectorNodes.map((n) => selectorToVElementMatcher(cleanSelectorChildren(n)));
+	return (element, subject) => selectors.some((sel) => sel(element, subject));
+}
+function isDescendantCombinator(node) {
+	return Boolean(node && node.type === "combinator" && !node.value.trim());
+}
+/**
+* Clean and get the selector child nodes.
+*/
+function cleanSelectorChildren(selector) {
+	const nodes = [];
+	let last = null;
+	for (const node of selector.nodes) {
+		if (node.type === "root") throw new SelectorError("Unexpected state type=root");
+		if (node.type === "comment") continue;
+		if ((last == null || last.type === "combinator") && isDescendantCombinator(node)) continue;
+		if (isDescendantCombinator(last) && node.type === "combinator") nodes.pop();
+		nodes.push(node);
+		last = node;
+	}
+	if (isDescendantCombinator(last)) nodes.pop();
+	return nodes;
+}
+/**
+* Convert Selector child nodes to VElementMatcher
+*/
+function selectorToVElementMatcher(selectorChildren) {
+	const nodes = [...selectorChildren];
+	let node = nodes.shift();
+	let result = null;
+	while (node) {
+		if (node.type === "combinator") {
+			const combinator = node.value;
+			node = nodes.shift();
+			if (!node) throw new SelectorError(`Expected selector after '${combinator}'.`);
+			if (node.type === "combinator") throw new SelectorError(`Unexpected combinator '${node.value}'.`);
+			const right = nodeToVElementMatcher(node);
+			result = combination(result || ((element, subject) => element === subject), combinator, right);
+		} else {
+			const sel = nodeToVElementMatcher(node);
+			result = result ? compound(result, sel) : sel;
+		}
+		node = nodes.shift();
+	}
+	if (!result) throw new SelectorError(`Unexpected empty selector.`);
+	return result;
+}
+function combination(left, combinator, right) {
+	switch (combinator.trim()) {
+		case "": return (element, subject) => {
+			if (right(element, null)) {
+				let parent = element.parent;
+				while (parent.type === "VElement") {
+					if (left(parent, subject)) return true;
+					parent = parent.parent;
+				}
+			}
+			return false;
+		};
+		case ">": return (element, subject) => {
+			if (right(element, null)) {
+				const parent = element.parent;
+				if (parent.type === "VElement") return left(parent, subject);
+			}
+			return false;
+		};
+		case "+": return (element, subject) => {
+			if (right(element, null)) {
+				const before = getBeforeElement(element);
+				if (before) return left(before, subject);
+			}
+			return false;
+		};
+		case "~": return (element, subject) => {
+			if (right(element, null)) {
+				for (const before of getBeforeElements(element)) if (left(before, subject)) return true;
+			}
+			return false;
+		};
+		default: throw new SelectorError(`Unknown combinator: ${combinator}.`);
+	}
+}
+/**
+* Convert node to VElementMatcher
+*/
+function nodeToVElementMatcher(selector) {
+	switch (selector.type) {
+		case "attribute": return attributeNodeToVElementMatcher(selector);
+		case "class": return classNameNodeToVElementMatcher(selector);
+		case "id": return identifierNodeToVElementMatcher(selector);
+		case "tag": return tagNodeToVElementMatcher(selector);
+		case "universal": return universalNodeToVElementMatcher(selector);
+		case "pseudo": return pseudoNodeToVElementMatcher(selector);
+		case "nesting": throw new SelectorError("Unsupported nesting selector.");
+		case "string": throw new SelectorError(`Unknown selector: ${selector.value}.`);
+		default: throw new SelectorError(`Unknown selector: ${selector.value}.`);
+	}
+}
+/**
+* Convert Attribute node to VElementMatcher
+*/
+function attributeNodeToVElementMatcher(selector) {
+	const key = selector.attribute;
+	if (!selector.operator) return (element) => getAttributeValue(element, key) != null;
+	const value = selector.value || "";
+	switch (selector.operator) {
+		case "=": return buildVElementMatcher(value, (attr, val) => attr === val);
+		case "~=": return buildVElementMatcher(value, (attr, val) => attr.split(/\s+/gu).includes(val));
+		case "|=": return buildVElementMatcher(value, (attr, val) => attr === val || attr.startsWith(`${val}-`));
+		case "^=": return buildVElementMatcher(value, (attr, val) => attr.startsWith(val));
+		case "$=": return buildVElementMatcher(value, (attr, val) => attr.endsWith(val));
+		case "*=": return buildVElementMatcher(value, (attr, val) => attr.includes(val));
+		default: throw new SelectorError(`Unsupported operator: ${selector.operator}.`);
+	}
+	function buildVElementMatcher(selectorValue, test) {
+		const val = selector.insensitive ? selectorValue.toLowerCase() : selectorValue;
+		return (element) => {
+			const attrValue = getAttributeValue(element, key);
+			if (attrValue == null) return false;
+			return test(selector.insensitive ? attrValue.toLowerCase() : attrValue, val);
+		};
+	}
+}
+/**
+* Convert ClassName node to VElementMatcher
+*/
+function classNameNodeToVElementMatcher(selector) {
+	const className = selector.value;
+	return (element) => {
+		const attrValue = getAttributeValue(element, "class");
+		if (attrValue == null) return false;
+		return attrValue.split(/\s+/gu).includes(className);
+	};
+}
+/**
+* Convert Identifier node to VElementMatcher
+*/
+function identifierNodeToVElementMatcher(selector) {
+	const id = selector.value;
+	return (element) => {
+		const attrValue = getAttributeValue(element, "id");
+		if (attrValue == null) return false;
+		return attrValue === id;
+	};
+}
+/**
+* Convert Tag node to VElementMatcher
+*/
+function tagNodeToVElementMatcher(selector) {
+	const name = selector.value;
+	return (element) => element.rawName === name;
+}
+/**
+* Convert Universal node to VElementMatcher
+*/
+function universalNodeToVElementMatcher(_selector) {
+	return () => true;
+}
+/**
+* Convert Pseudo node to VElementMatcher
+*/
+function pseudoNodeToVElementMatcher(selector) {
+	const pseudo = selector.value;
+	switch (pseudo) {
+		case ":not": {
+			const selectors = selectorsToVElementMatcher(selector.nodes);
+			return (element, subject) => !selectors(element, subject);
+		}
+		case ":is":
+		case ":where": return selectorsToVElementMatcher(selector.nodes);
+		case ":has": return pseudoHasSelectorsToVElementMatcher(selector.nodes);
+		case ":empty": return (element) => element.children.every((child) => child.type === "VText" && !child.value.trim());
+		case ":nth-child": return buildPseudoNthVElementMatcher(parseNth(selector));
+		case ":nth-last-child": {
+			const nth = parseNth(selector);
+			return buildPseudoNthVElementMatcher((index, length) => nth(length - index - 1));
+		}
+		case ":first-child": return buildPseudoNthVElementMatcher((index) => index === 0);
+		case ":last-child": return buildPseudoNthVElementMatcher((index, length) => index === length - 1);
+		case ":only-child": return buildPseudoNthVElementMatcher((index, length) => index === 0 && length === 1);
+		case ":nth-of-type": return buildPseudoNthOfTypeVElementMatcher(parseNth(selector));
+		case ":nth-last-of-type": {
+			const nth = parseNth(selector);
+			return buildPseudoNthOfTypeVElementMatcher((index, length) => nth(length - index - 1));
+		}
+		case ":first-of-type": return buildPseudoNthOfTypeVElementMatcher((index) => index === 0);
+		case ":last-of-type": return buildPseudoNthOfTypeVElementMatcher((index, length) => index === length - 1);
+		case ":only-of-type": return buildPseudoNthOfTypeVElementMatcher((index, length) => index === 0 && length === 1);
+		default: throw new SelectorError(`Unsupported pseudo selector: ${pseudo}.`);
+	}
+}
+/**
+* Convert :has() selector nodes to VElementMatcher
+*/
+function pseudoHasSelectorsToVElementMatcher(selectorNodes) {
+	const selectors = selectorNodes.map((n) => pseudoHasSelectorToVElementMatcher(n));
+	return (element, subject) => selectors.some((sel) => sel(element, subject));
+}
+/**
+* Convert :has() selector node to VElementMatcher
+*/
+function pseudoHasSelectorToVElementMatcher(selector) {
+	const nodes = cleanSelectorChildren(selector);
+	const selectors = selectorToVElementMatcher(nodes);
+	const firstNode = nodes[0];
+	if (firstNode.type === "combinator" && (firstNode.value === "+" || firstNode.value === "~")) return buildVElementMatcher(selectors, (element) => getAfterElements(element));
+	return buildVElementMatcher(selectors, (element) => element.children.filter(import_utils.default.isVElement));
+}
+function buildVElementMatcher(selectors, getStartElements) {
+	return (element) => {
+		const elements = [...getStartElements(element)];
+		let curr;
+		while (curr = elements.shift()) {
+			const el = curr;
+			if (selectors(el, element)) return true;
+			elements.push(...el.children.filter(import_utils.default.isVElement));
+		}
+		return false;
+	};
+}
+/**
+* Parse <nth>
+*/
+function parseNth(pseudoNode) {
+	const argumentsText = pseudoNode.toString().slice(pseudoNode.value.length).toLowerCase();
+	const openParenIndex = argumentsText.indexOf("(");
+	const closeParenIndex = argumentsText.lastIndexOf(")");
+	if (openParenIndex === -1 || closeParenIndex === -1) throw new SelectorError(`Cannot parse An+B micro syntax (:nth-xxx() argument): ${argumentsText}.`);
+	const argument = argumentsText.slice(openParenIndex + 1, closeParenIndex).trim();
+	try {
+		return (0, nth_check.default)(argument);
+	} catch {
+		throw new SelectorError(`Cannot parse An+B micro syntax (:nth-xxx() argument): '${argument}'.`);
+	}
+}
+/**
+* Build VElementMatcher for :nth-xxx()
+*/
+function buildPseudoNthVElementMatcher(testIndex) {
+	return (element) => {
+		const elements = element.parent.children.filter(import_utils.default.isVElement);
+		return testIndex(elements.indexOf(element), elements.length);
+	};
+}
+/**
+* Build VElementMatcher for :nth-xxx-of-type()
+*/
+function buildPseudoNthOfTypeVElementMatcher(testIndex) {
+	return (element) => {
+		const elements = element.parent.children.filter((e) => import_utils.default.isVElement(e) && e.rawName === element.rawName);
+		return testIndex(elements.indexOf(element), elements.length);
+	};
+}
+function getBeforeElement(element) {
+	return getBeforeElements(element).pop() || null;
+}
+function getBeforeElements(element) {
+	const parent = element.parent;
+	const index = parent.children.indexOf(element);
+	return parent.children.slice(0, index).filter(import_utils.default.isVElement);
+}
+function getAfterElements(element) {
+	const parent = element.parent;
+	const index = parent.children.indexOf(element);
+	return parent.children.slice(index + 1).filter(import_utils.default.isVElement);
+}
+function compound(a, b) {
+	return (element, subject) => a(element, subject) && b(element, subject);
+}
+/**
+* Get attribute value from given element.
+*/
+function getAttributeValue(element, attribute) {
+	const attr = import_utils.default.getAttribute(element, attribute);
+	if (attr) return attr.value && attr.value.value || "";
+	return null;
+}
+
+//#endregion
+exports.parseSelector = parseSelector;

frontend/node_modules/eslint-plugin-vue/dist/utils/style-variables/index.js

@@ -0,0 +1,38 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../index.js');
+
+//#region lib/utils/style-variables/index.ts
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+var StyleVariablesContext = class {
+	context;
+	styles;
+	references = [];
+	vBinds = [];
+	constructor(context, styles) {
+		this.context = context;
+		this.styles = styles;
+		for (const style of styles) for (const node of style.children) if (node.type === "VExpressionContainer") {
+			this.vBinds.push(node);
+			for (const ref of node.references.filter((ref) => ref.variable == null)) this.references.push(ref);
+		}
+	}
+};
+const cache = /* @__PURE__ */ new WeakMap();
+/**
+* Get the style vars context
+*/
+function getStyleVariablesContext(context) {
+	const sourceCode = context.sourceCode;
+	const df = sourceCode.parserServices.getDocumentFragment && sourceCode.parserServices.getDocumentFragment();
+	if (!df) return null;
+	const styles = df.children.filter((e) => import_utils.default.isVElement(e) && e.name === "style");
+	if (styles.length === 0) return null;
+	let ctx = cache.get(styles[0]);
+	if (ctx) return ctx;
+	ctx = new StyleVariablesContext(context, styles);
+	cache.set(styles[0], ctx);
+	return ctx;
+}
+
+//#endregion
+exports.getStyleVariablesContext = getStyleVariablesContext;

frontend/node_modules/eslint-plugin-vue/dist/utils/svg-attributes-weird-case.js

@@ -0,0 +1,148 @@
+
+//#region lib/utils/svg-attributes-weird-case.json
+var svg_attributes_weird_case_default = [
+	"accent-height",
+	"alignment-baseline",
+	"arabic-form",
+	"attributeName",
+	"attributeType",
+	"baseFrequency",
+	"baseline-shift",
+	"baseProfile",
+	"calcMode",
+	"cap-height",
+	"clipPathUnits",
+	"clip-path",
+	"clip-rule",
+	"color-interpolation",
+	"color-interpolation-filters",
+	"color-profile",
+	"color-rendering",
+	"contentScriptType",
+	"contentStyleType",
+	"diffuseConstant",
+	"dominant-baseline",
+	"edgeMode",
+	"enable-background",
+	"externalResourcesRequired",
+	"fill-opacity",
+	"fill-rule",
+	"filterRes",
+	"filterUnits",
+	"flood-color",
+	"flood-opacity",
+	"font-family",
+	"font-size",
+	"font-size-adjust",
+	"font-stretch",
+	"font-style",
+	"font-variant",
+	"font-weight",
+	"glyph-name",
+	"glyph-orientation-horizontal",
+	"glyph-orientation-vertical",
+	"glyphRef",
+	"gradientTransform",
+	"gradientUnits",
+	"horiz-adv-x",
+	"horiz-origin-x",
+	"image-rendering",
+	"kernelMatrix",
+	"kernelUnitLength",
+	"keyPoints",
+	"keySplines",
+	"keyTimes",
+	"lengthAdjust",
+	"letter-spacing",
+	"lighting-color",
+	"limitingConeAngle",
+	"marker-end",
+	"marker-mid",
+	"marker-start",
+	"markerHeight",
+	"markerUnits",
+	"markerWidth",
+	"maskContentUnits",
+	"maskUnits",
+	"numOctaves",
+	"overline-position",
+	"overline-thickness",
+	"panose-1",
+	"paint-order",
+	"pathLength",
+	"patternContentUnits",
+	"patternTransform",
+	"patternUnits",
+	"pointer-events",
+	"pointsAtX",
+	"pointsAtY",
+	"pointsAtZ",
+	"preserveAlpha",
+	"preserveAspectRatio",
+	"primitiveUnits",
+	"referrerPolicy",
+	"refX",
+	"refY",
+	"rendering-intent",
+	"repeatCount",
+	"repeatDur",
+	"requiredExtensions",
+	"requiredFeatures",
+	"shape-rendering",
+	"specularConstant",
+	"specularExponent",
+	"spreadMethod",
+	"startOffset",
+	"stdDeviation",
+	"stitchTiles",
+	"stop-color",
+	"stop-opacity",
+	"strikethrough-position",
+	"strikethrough-thickness",
+	"stroke-dasharray",
+	"stroke-dashoffset",
+	"stroke-linecap",
+	"stroke-linejoin",
+	"stroke-miterlimit",
+	"stroke-opacity",
+	"stroke-width",
+	"surfaceScale",
+	"systemLanguage",
+	"tableValues",
+	"targetX",
+	"targetY",
+	"text-anchor",
+	"text-decoration",
+	"text-rendering",
+	"textLength",
+	"transform-origin",
+	"underline-position",
+	"underline-thickness",
+	"unicode-bidi",
+	"unicode-range",
+	"units-per-em",
+	"v-alphabetic",
+	"v-hanging",
+	"v-ideographic",
+	"v-mathematical",
+	"vector-effect",
+	"vert-adv-y",
+	"vert-origin-x",
+	"vert-origin-y",
+	"viewBox",
+	"viewTarget",
+	"word-spacing",
+	"writing-mode",
+	"x-height",
+	"xChannelSelector",
+	"yChannelSelector",
+	"zoomAndPan"
+];
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return svg_attributes_weird_case_default;
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/svg-elements.js

@@ -0,0 +1,78 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/svg-elements.json
+var require_svg_elements = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"a",
+		"animate",
+		"animateMotion",
+		"animateTransform",
+		"circle",
+		"clipPath",
+		"defs",
+		"desc",
+		"ellipse",
+		"feBlend",
+		"feColorMatrix",
+		"feComponentTransfer",
+		"feComposite",
+		"feConvolveMatrix",
+		"feDiffuseLighting",
+		"feDisplacementMap",
+		"feDistantLight",
+		"feDropShadow",
+		"feFlood",
+		"feFuncA",
+		"feFuncB",
+		"feFuncG",
+		"feFuncR",
+		"feGaussianBlur",
+		"feImage",
+		"feMerge",
+		"feMergeNode",
+		"feMorphology",
+		"feOffset",
+		"fePointLight",
+		"feSpecularLighting",
+		"feSpotLight",
+		"feTile",
+		"feTurbulence",
+		"filter",
+		"foreignObject",
+		"g",
+		"image",
+		"line",
+		"linearGradient",
+		"marker",
+		"mask",
+		"metadata",
+		"mpath",
+		"path",
+		"pattern",
+		"polygon",
+		"polyline",
+		"radialGradient",
+		"rect",
+		"script",
+		"set",
+		"stop",
+		"style",
+		"svg",
+		"switch",
+		"symbol",
+		"text",
+		"textPath",
+		"title",
+		"tspan",
+		"use",
+		"view"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_svg_elements();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/ts-utils/index.js

@@ -0,0 +1,76 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_ts_types$1 = require('./ts-types.js');
+const require_ts_ast$1 = require('./ts-ast.js');
+
+//#region lib/utils/ts-utils/index.js
+var require_ts_utils = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const { isTypeNode, extractRuntimeProps, isTSTypeLiteral, isTSTypeLiteralOrTSFunctionType, extractRuntimeEmits, flattenTypeNodes, isTSInterfaceBody, extractRuntimeSlots } = require_ts_ast$1.default;
+	const { getComponentPropsFromTypeDefineTypes, getComponentEmitsFromTypeDefineTypes, getComponentSlotsFromTypeDefineTypes } = require_ts_types$1.default;
+	/**
+	* @typedef {import('@typescript-eslint/types').TSESTree.TypeNode} TSESTreeTypeNode
+	*/
+	/**
+	* @typedef {import('../index').ComponentTypeProp} ComponentTypeProp
+	* @typedef {import('../index').ComponentInferTypeProp} ComponentInferTypeProp
+	* @typedef {import('../index').ComponentUnknownProp} ComponentUnknownProp
+	* @typedef {import('../index').ComponentTypeEmit} ComponentTypeEmit
+	* @typedef {import('../index').ComponentInferTypeEmit} ComponentInferTypeEmit
+	* @typedef {import('../index').ComponentUnknownEmit} ComponentUnknownEmit
+	* @typedef {import('../index').ComponentTypeSlot} ComponentTypeSlot
+	* @typedef {import('../index').ComponentInferTypeSlot} ComponentInferTypeSlot
+	* @typedef {import('../index').ComponentUnknownSlot} ComponentUnknownSlot
+	*/
+	module.exports = {
+		isTypeNode,
+		getComponentPropsFromTypeDefine,
+		getComponentEmitsFromTypeDefine,
+		getComponentSlotsFromTypeDefine
+	};
+	/**
+	* Get all props by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} propsNode Type with props definition
+	* @return {(ComponentTypeProp|ComponentInferTypeProp|ComponentUnknownProp)[]} Array of component props
+	*/
+	function getComponentPropsFromTypeDefine(context, propsNode) {
+		/** @type {(ComponentTypeProp|ComponentInferTypeProp|ComponentUnknownProp)[]} */
+		const result = [];
+		for (const defNode of flattenTypeNodes(context, propsNode)) if (isTSInterfaceBody(defNode) || isTSTypeLiteral(defNode)) result.push(...extractRuntimeProps(context, defNode));
+		else result.push(...getComponentPropsFromTypeDefineTypes(context, defNode));
+		return result;
+	}
+	/**
+	* Get all emits by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} emitsNode Type with emits definition
+	* @return {(ComponentTypeEmit|ComponentInferTypeEmit|ComponentUnknownEmit)[]} Array of component emits
+	*/
+	function getComponentEmitsFromTypeDefine(context, emitsNode) {
+		/** @type {(ComponentTypeEmit|ComponentInferTypeEmit|ComponentUnknownEmit)[]} */
+		const result = [];
+		for (const defNode of flattenTypeNodes(context, emitsNode)) if (isTSInterfaceBody(defNode) || isTSTypeLiteralOrTSFunctionType(defNode)) result.push(...extractRuntimeEmits(defNode));
+		else result.push(...getComponentEmitsFromTypeDefineTypes(context, defNode));
+		return result;
+	}
+	/**
+	* Get all slots by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} slotsNode Type with slots definition
+	* @return {(ComponentTypeSlot|ComponentInferTypeSlot|ComponentUnknownSlot)[]} Array of component slots
+	*/
+	function getComponentSlotsFromTypeDefine(context, slotsNode) {
+		/** @type {(ComponentTypeSlot|ComponentInferTypeSlot|ComponentUnknownSlot)[]} */
+		const result = [];
+		for (const defNode of flattenTypeNodes(context, slotsNode)) if (isTSInterfaceBody(defNode) || isTSTypeLiteral(defNode)) result.push(...extractRuntimeSlots(defNode));
+		else result.push(...getComponentSlotsFromTypeDefineTypes(context, defNode));
+		return result;
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ts_utils();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/ts-utils/ts-ast.js

@@ -0,0 +1,385 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_scope$1 = require('../scope.js');
+const require_ts_types$1 = require('./ts-types.js');
+
+//#region lib/utils/ts-utils/ts-ast.js
+var require_ts_ast = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const { getScope } = require_scope$1.default;
+	const { findVariable } = require("@eslint-community/eslint-utils");
+	const { inferRuntimeTypeFromTypeNode } = require_ts_types$1.default;
+	/**
+	* @typedef {import('@typescript-eslint/types').TSESTree.TypeNode} TSESTreeTypeNode
+	* @typedef {import('@typescript-eslint/types').TSESTree.TSInterfaceBody} TSESTreeTSInterfaceBody
+	* @typedef {import('@typescript-eslint/types').TSESTree.TSTypeLiteral} TSESTreeTSTypeLiteral
+	* @typedef {import('@typescript-eslint/types').TSESTree.TSFunctionType} TSESTreeTSFunctionType
+	* @typedef {import('@typescript-eslint/types').TSESTree.Parameter} TSESTreeParameter
+	* @typedef {import('@typescript-eslint/types').TSESTree.Node} TSESTreeNode
+	*
+	*/
+	/**
+	* @typedef {import('../index').ComponentTypeProp} ComponentTypeProp
+	* @typedef {import('../index').ComponentUnknownProp} ComponentUnknownProp
+	* @typedef {import('../index').ComponentTypeEmit} ComponentTypeEmit
+	* @typedef {import('../index').ComponentUnknownEmit} ComponentUnknownEmit
+	* @typedef {import('../index').ComponentTypeSlot} ComponentTypeSlot
+	* @typedef {import('../index').ComponentUnknownSlot} ComponentUnknownSlot
+	*/
+	const noop = Function.prototype;
+	module.exports = {
+		isTypeNode,
+		flattenTypeNodes,
+		isTSInterfaceBody,
+		isTSTypeLiteral,
+		isTSTypeLiteralOrTSFunctionType,
+		extractRuntimeProps,
+		extractRuntimeEmits,
+		extractRuntimeSlots
+	};
+	/**
+	* @param {ASTNode} node
+	* @returns {node is TypeNode}
+	*/
+	function isTypeNode(node) {
+		if (node.type === "TSAbstractKeyword" || node.type === "TSAnyKeyword" || node.type === "TSAsyncKeyword" || node.type === "TSArrayType" || node.type === "TSBigIntKeyword" || node.type === "TSBooleanKeyword" || node.type === "TSConditionalType" || node.type === "TSConstructorType" || node.type === "TSDeclareKeyword" || node.type === "TSExportKeyword" || node.type === "TSFunctionType" || node.type === "TSImportType" || node.type === "TSIndexedAccessType" || node.type === "TSInferType" || node.type === "TSIntersectionType" || node.type === "TSIntrinsicKeyword" || node.type === "TSLiteralType" || node.type === "TSMappedType" || node.type === "TSNamedTupleMember" || node.type === "TSNeverKeyword" || node.type === "TSNullKeyword" || node.type === "TSNumberKeyword" || node.type === "TSObjectKeyword" || node.type === "TSOptionalType" || node.type === "TSQualifiedName" || node.type === "TSPrivateKeyword" || node.type === "TSProtectedKeyword" || node.type === "TSPublicKeyword" || node.type === "TSReadonlyKeyword" || node.type === "TSRestType" || node.type === "TSStaticKeyword" || node.type === "TSStringKeyword" || node.type === "TSSymbolKeyword" || node.type === "TSTemplateLiteralType" || node.type === "TSThisType" || node.type === "TSTupleType" || node.type === "TSTypeLiteral" || node.type === "TSTypeOperator" || node.type === "TSTypePredicate" || node.type === "TSTypeQuery" || node.type === "TSTypeReference" || node.type === "TSUndefinedKeyword" || node.type === "TSUnionType" || node.type === "TSUnknownKeyword" || node.type === "TSVoidKeyword") {
+			/** @type {TypeNode['type']} for type check */
+			const type = node.type;
+			noop(type);
+			return true;
+		}
+		/** @type {Exclude<ASTNode['type'], TypeNode['type']>} for type check */
+		const type = node.type;
+		noop(type);
+		return false;
+	}
+	/**
+	* @param {TSESTreeTypeNode|TSESTreeTSInterfaceBody} node
+	* @returns {node is TSESTreeTSInterfaceBody}
+	*/
+	function isTSInterfaceBody(node) {
+		return node.type === "TSInterfaceBody";
+	}
+	/**
+	* @param {TSESTreeTypeNode} node
+	* @returns {node is TSESTreeTSTypeLiteral}
+	*/
+	function isTSTypeLiteral(node) {
+		return node.type === "TSTypeLiteral";
+	}
+	/**
+	* @param {TSESTreeTypeNode} node
+	* @returns {node is TSESTreeTSFunctionType}
+	*/
+	function isTSFunctionType(node) {
+		return node.type === "TSFunctionType";
+	}
+	/**
+	* @param {TSESTreeTypeNode} node
+	* @returns {node is TSESTreeTSTypeLiteral | TSESTreeTSFunctionType}
+	*/
+	function isTSTypeLiteralOrTSFunctionType(node) {
+		return isTSTypeLiteral(node) || isTSFunctionType(node);
+	}
+	/**
+	* @see https://github.com/vuejs/vue-next/blob/253ca2729d808fc051215876aa4af986e4caa43c/packages/compiler-sfc/src/compileScript.ts#L1512
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TSESTreeTSTypeLiteral | TSESTreeTSInterfaceBody} node
+	* @returns {IterableIterator<ComponentTypeProp | ComponentUnknownProp>}
+	*/
+	function* extractRuntimeProps(context, node) {
+		const members = node.type === "TSTypeLiteral" ? node.members : node.body;
+		for (const member of members) if (member.type === "TSPropertySignature" || member.type === "TSMethodSignature") {
+			if (member.key.type !== "Identifier" && member.key.type !== "Literal") {
+				yield {
+					type: "unknown",
+					propName: null,
+					node: member.key
+				};
+				continue;
+			}
+			/** @type {string[]|undefined} */
+			let types;
+			if (member.type === "TSMethodSignature") types = ["Function"];
+			else if (member.typeAnnotation) types = inferRuntimeType(context, member.typeAnnotation.typeAnnotation);
+			yield {
+				type: "type",
+				key: member.key,
+				propName: member.key.type === "Identifier" ? member.key.name : `${member.key.value}`,
+				node: member,
+				required: !member.optional,
+				types: types || [`null`]
+			};
+		}
+	}
+	/**
+	* @param {TSESTreeTSTypeLiteral | TSESTreeTSInterfaceBody | TSESTreeTSFunctionType} node
+	* @returns {IterableIterator<ComponentTypeEmit | ComponentUnknownEmit>}
+	*/
+	function* extractRuntimeEmits(node) {
+		if (node.type === "TSFunctionType") {
+			yield* extractEventNames(node.params[0], node);
+			return;
+		}
+		const members = node.type === "TSTypeLiteral" ? node.members : node.body;
+		for (const member of members) if (member.type === "TSCallSignatureDeclaration") yield* extractEventNames(member.params[0], member);
+		else if (member.type === "TSPropertySignature" || member.type === "TSMethodSignature") {
+			if (member.key.type !== "Identifier" && member.key.type !== "Literal") {
+				yield {
+					type: "unknown",
+					emitName: null,
+					node: member.key
+				};
+				continue;
+			}
+			yield {
+				type: "type",
+				key: member.key,
+				emitName: member.key.type === "Identifier" ? member.key.name : `${member.key.value}`,
+				node: member
+			};
+		}
+	}
+	/**
+	* @param {TSESTreeTSTypeLiteral | TSESTreeTSInterfaceBody} node
+	* @returns {IterableIterator<ComponentTypeSlot | ComponentUnknownSlot>}
+	*/
+	function* extractRuntimeSlots(node) {
+		const members = node.type === "TSTypeLiteral" ? node.members : node.body;
+		for (const member of members) if (member.type === "TSPropertySignature" || member.type === "TSMethodSignature") {
+			if (member.key.type !== "Identifier" && member.key.type !== "Literal") {
+				yield {
+					type: "unknown",
+					slotName: null,
+					node: member.key
+				};
+				continue;
+			}
+			yield {
+				type: "type",
+				key: member.key,
+				slotName: member.key.type === "Identifier" ? member.key.name : `${member.key.value}`,
+				node: member
+			};
+		}
+	}
+	/**
+	* @param {TSESTreeParameter} eventName
+	* @param {TSCallSignatureDeclaration | TSFunctionType} member
+	* @returns {IterableIterator<ComponentTypeEmit>}
+	*/
+	function* extractEventNames(eventName, member) {
+		if (eventName && eventName.type === "Identifier" && eventName.typeAnnotation && eventName.typeAnnotation.type === "TSTypeAnnotation") {
+			const typeNode = eventName.typeAnnotation.typeAnnotation;
+			if (typeNode.type === "TSLiteralType" && typeNode.literal.type === "Literal") yield {
+				type: "type",
+				key: typeNode,
+				emitName: String(typeNode.literal.value),
+				node: member
+			};
+			else if (typeNode.type === "TSUnionType") {
+				for (const t of typeNode.types) if (t.type === "TSLiteralType" && t.literal.type === "Literal") yield {
+					type: "type",
+					key: t,
+					emitName: String(t.literal.value),
+					node: member
+				};
+			}
+		}
+	}
+	/**
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TSESTreeTypeNode} node
+	* @returns {(TSESTreeTypeNode|TSESTreeTSInterfaceBody)[]}
+	*/
+	function flattenTypeNodes(context, node) {
+		/**
+		* @typedef {object} TraversedData
+		* @property {Set<TSESTreeTypeNode|TSESTreeTSInterfaceBody>} nodes
+		* @property {boolean} finished
+		*/
+		/** @type {Map<TSESTreeTypeNode,TraversedData>} */
+		const traversed = /* @__PURE__ */ new Map();
+		return [...flattenImpl(node)];
+		/**
+		* @param {TSESTreeTypeNode} node
+		* @returns {Iterable<TSESTreeTypeNode|TSESTreeTSInterfaceBody>}
+		*/
+		function* flattenImpl(node) {
+			if (node.type === "TSUnionType" || node.type === "TSIntersectionType") {
+				for (const typeNode of node.types) yield* flattenImpl(typeNode);
+				return;
+			}
+			if (node.type === "TSTypeReference" && node.typeName.type === "Identifier") {
+				const refName = node.typeName.name;
+				const variable = findVariable(getScope(context, node), refName);
+				if (variable && variable.defs.length === 1) {
+					const defNode = variable.defs[0].node;
+					if (defNode.type === "TSInterfaceDeclaration") {
+						yield defNode.body;
+						return;
+					} else if (defNode.type === "TSTypeAliasDeclaration") {
+						const typeAnnotation = defNode.typeAnnotation;
+						let traversedData = traversed.get(typeAnnotation);
+						if (traversedData) {
+							yield* [...traversedData.nodes];
+							if (!traversedData.finished) yield typeAnnotation;
+							return;
+						}
+						traversedData = {
+							nodes: /* @__PURE__ */ new Set(),
+							finished: false
+						};
+						traversed.set(typeAnnotation, traversedData);
+						for (const e of flattenImpl(typeAnnotation)) traversedData.nodes.add(e);
+						traversedData.finished = true;
+						yield* traversedData.nodes;
+						return;
+					}
+				}
+			}
+			yield node;
+		}
+	}
+	/**
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TSESTreeTypeNode} node
+	* @param {Set<TSESTreeTypeNode>} [checked]
+	* @returns {string[]}
+	*/
+	function inferRuntimeType(context, node, checked = /* @__PURE__ */ new Set()) {
+		switch (node.type) {
+			case "TSStringKeyword":
+			case "TSTemplateLiteralType": return ["String"];
+			case "TSNumberKeyword": return ["Number"];
+			case "TSBooleanKeyword": return ["Boolean"];
+			case "TSObjectKeyword": return ["Object"];
+			case "TSTypeLiteral": return inferTypeLiteralType(node);
+			case "TSFunctionType": return ["Function"];
+			case "TSArrayType":
+			case "TSTupleType": return ["Array"];
+			case "TSSymbolKeyword": return ["Symbol"];
+			case "TSLiteralType":
+				if (node.literal.type === "Literal") switch (typeof node.literal.value) {
+					case "boolean": return ["Boolean"];
+					case "string": return ["String"];
+					case "number":
+					case "bigint": return ["Number"];
+				}
+				return inferRuntimeTypeFromTypeNode(context, node);
+			case "TSTypeReference":
+				if (node.typeName.type === "Identifier") {
+					const variable = findVariable(getScope(context, node), node.typeName.name);
+					if (variable && variable.defs.length === 1) {
+						const defNode = variable.defs[0].node;
+						if (defNode.type === "TSInterfaceDeclaration") return [`Object`];
+						if (defNode.type === "TSTypeAliasDeclaration") {
+							const typeAnnotation = defNode.typeAnnotation;
+							if (!checked.has(typeAnnotation)) {
+								checked.add(typeAnnotation);
+								return inferRuntimeType(context, typeAnnotation, checked);
+							}
+						}
+						if (defNode.type === "TSEnumDeclaration") return inferEnumType(context, defNode);
+					}
+					for (const name of [node.typeName.name, ...node.typeName.name.startsWith("Readonly") ? [node.typeName.name.slice(8)] : []]) switch (name) {
+						case "Array":
+						case "Function":
+						case "Object":
+						case "Set":
+						case "Map":
+						case "WeakSet":
+						case "WeakMap":
+						case "Date": return [name];
+					}
+					switch (node.typeName.name) {
+						case "Record":
+						case "Partial":
+						case "Readonly":
+						case "Pick":
+						case "Omit":
+						case "Required":
+						case "InstanceType": return ["Object"];
+						case "Uppercase":
+						case "Lowercase":
+						case "Capitalize":
+						case "Uncapitalize": return ["String"];
+						case "Parameters":
+						case "ConstructorParameters": return ["Array"];
+						case "NonNullable": {
+							const typeArguments = "typeArguments" in node ? node.typeArguments : node.typeParameters;
+							if (typeArguments && typeArguments.params[0]) return inferRuntimeType(context, typeArguments.params[0], checked).filter((t) => t !== "null");
+							break;
+						}
+						case "Extract": {
+							const typeArguments = "typeArguments" in node ? node.typeArguments : node.typeParameters;
+							if (typeArguments && typeArguments.params[1]) return inferRuntimeType(context, typeArguments.params[1], checked);
+							break;
+						}
+						case "Exclude":
+						case "OmitThisParameter": {
+							const typeArguments = "typeArguments" in node ? node.typeArguments : node.typeParameters;
+							if (typeArguments && typeArguments.params[0]) return inferRuntimeType(context, typeArguments.params[0], checked);
+							break;
+						}
+					}
+				}
+				return inferRuntimeTypeFromTypeNode(context, node);
+			case "TSUnionType":
+			case "TSIntersectionType": return inferUnionType(node);
+			default: return inferRuntimeTypeFromTypeNode(context, node);
+		}
+		/**
+		* @param {import('@typescript-eslint/types').TSESTree.TSUnionType|import('@typescript-eslint/types').TSESTree.TSIntersectionType} node
+		* @returns {string[]}
+		*/
+		function inferUnionType(node) {
+			const types = /* @__PURE__ */ new Set();
+			for (const t of node.types) for (const tt of inferRuntimeType(context, t, checked)) types.add(tt);
+			return [...types];
+		}
+	}
+	/**
+	* @param {import('@typescript-eslint/types').TSESTree.TSTypeLiteral} node
+	* @returns {string[]}
+	*/
+	function inferTypeLiteralType(node) {
+		const types = /* @__PURE__ */ new Set();
+		for (const m of node.members) switch (m.type) {
+			case "TSCallSignatureDeclaration":
+			case "TSConstructSignatureDeclaration":
+				types.add("Function");
+				break;
+			default: types.add("Object");
+		}
+		return types.size > 0 ? [...types] : ["Object"];
+	}
+	/**
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {import('@typescript-eslint/types').TSESTree.TSEnumDeclaration} node
+	* @returns {string[]}
+	*/
+	function inferEnumType(context, node) {
+		const types = /* @__PURE__ */ new Set();
+		for (const m of node.members) if (m.initializer) if (m.initializer.type === "Literal") switch (typeof m.initializer.value) {
+			case "string":
+				types.add("String");
+				break;
+			case "number":
+			case "bigint":
+				types.add("Number");
+				break;
+			case "boolean":
+				types.add("Boolean");
+				break;
+		}
+		else for (const type of inferRuntimeTypeFromTypeNode(context, m.initializer)) types.add(type);
+		return types.size > 0 ? [...types] : ["Number"];
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ts_ast();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/ts-utils/ts-types.js

@@ -0,0 +1,231 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_typescript$1 = require('./typescript.js');
+
+//#region lib/utils/ts-utils/ts-types.js
+var require_ts_types = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const { getTypeScript, isAny, isUnknown, isNever, isNull, isObject, isFunction, isStringLike, isNumberLike, isBooleanLike, isBigIntLike, isArrayLikeObject, isReferenceObject } = require_typescript$1.default;
+	/**
+	* @typedef {import('@typescript-eslint/types').TSESTree.Node} TSESTreeNode
+	* @typedef {import('typescript').Type} Type
+	* @typedef {import('typescript').TypeChecker} TypeChecker
+	* @typedef {import('typescript').Node} TypeScriptNode
+	*/
+	/**
+	* @typedef {import('../index').ComponentInferTypeProp} ComponentInferTypeProp
+	* @typedef {import('../index').ComponentUnknownProp} ComponentUnknownProp
+	* @typedef {import('../index').ComponentInferTypeEmit} ComponentInferTypeEmit
+	* @typedef {import('../index').ComponentUnknownEmit} ComponentUnknownEmit
+	* @typedef {import('../index').ComponentInferTypeSlot} ComponentInferTypeSlot
+	* @typedef {import('../index').ComponentUnknownSlot} ComponentUnknownSlot
+	*/
+	module.exports = {
+		getComponentPropsFromTypeDefineTypes,
+		getComponentEmitsFromTypeDefineTypes,
+		getComponentSlotsFromTypeDefineTypes,
+		inferRuntimeTypeFromTypeNode
+	};
+	/**
+	* @typedef {object} Services
+	* @property {typeof import("typescript")} ts
+	* @property {Map<ESNode | TSNode | TSESTreeNode, TypeScriptNode>} tsNodeMap
+	* @property {import('typescript').TypeChecker} checker
+	*/
+	/**
+	* Get TypeScript parser services.
+	* @param {RuleContext} context The ESLint rule context object.
+	* @returns {Services|null}
+	*/
+	function getTSParserServices(context) {
+		const sourceCode = context.sourceCode;
+		const tsNodeMap = sourceCode.parserServices.esTreeNodeToTSNodeMap;
+		if (!tsNodeMap) return null;
+		const checker = sourceCode.parserServices.hasFullTypeInformation !== false && sourceCode.parserServices.program && sourceCode.parserServices.program.getTypeChecker() || null;
+		if (!checker) return null;
+		const ts = getTypeScript();
+		if (!ts) return null;
+		return {
+			ts,
+			tsNodeMap,
+			checker
+		};
+	}
+	/**
+	* Get all props by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} propsNode Type with props definition
+	* @return {(ComponentInferTypeProp|ComponentUnknownProp)[]} Array of component props
+	*/
+	function getComponentPropsFromTypeDefineTypes(context, propsNode) {
+		const services = getTSParserServices(context);
+		const tsNode = services && services.tsNodeMap.get(propsNode);
+		const type = tsNode && services.checker.getTypeAtLocation(tsNode);
+		if (!type || isAny(type) || isUnknown(type) || isNever(type) || isNull(type)) return [{
+			type: "unknown",
+			propName: null,
+			node: propsNode
+		}];
+		return [...extractRuntimeProps(type, tsNode, propsNode, services)];
+	}
+	/**
+	* Get all emits by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} emitsNode Type with emits definition
+	* @return {(ComponentInferTypeEmit|ComponentUnknownEmit)[]} Array of component emits
+	*/
+	function getComponentEmitsFromTypeDefineTypes(context, emitsNode) {
+		const services = getTSParserServices(context);
+		const tsNode = services && services.tsNodeMap.get(emitsNode);
+		const type = tsNode && services.checker.getTypeAtLocation(tsNode);
+		if (!type || isAny(type) || isUnknown(type) || isNever(type) || isNull(type)) return [{
+			type: "unknown",
+			emitName: null,
+			node: emitsNode
+		}];
+		return [...extractRuntimeEmits(type, tsNode, emitsNode, services)];
+	}
+	/**
+	* Get all slots by looking at all component's properties
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode} slotsNode Type with slots definition
+	* @return {(ComponentInferTypeSlot|ComponentUnknownSlot)[]} Array of component slots
+	*/
+	function getComponentSlotsFromTypeDefineTypes(context, slotsNode) {
+		const services = getTSParserServices(context);
+		const tsNode = services && services.tsNodeMap.get(slotsNode);
+		const type = tsNode && services.checker.getTypeAtLocation(tsNode);
+		if (!type || isAny(type) || isUnknown(type) || isNever(type) || isNull(type)) return [{
+			type: "unknown",
+			slotName: null,
+			node: slotsNode
+		}];
+		return [...extractRuntimeSlots(type, slotsNode)];
+	}
+	/**
+	* @param {RuleContext} context The ESLint rule context object.
+	* @param {TypeNode|Expression} node
+	* @returns {string[]}
+	*/
+	function inferRuntimeTypeFromTypeNode(context, node) {
+		const services = getTSParserServices(context);
+		const tsNode = services && services.tsNodeMap.get(node);
+		const type = tsNode && services.checker.getTypeAtLocation(tsNode);
+		if (!type) return ["null"];
+		return inferRuntimeTypeInternal(type, services);
+	}
+	/**
+	* @param {Type} type
+	* @param {TypeScriptNode} tsNode
+	* @param {TypeNode} propsNode Type with props definition
+	* @param {Services} services
+	* @returns {IterableIterator<ComponentInferTypeProp>}
+	*/
+	function* extractRuntimeProps(type, tsNode, propsNode, services) {
+		const { ts, checker } = services;
+		for (const property of type.getProperties()) {
+			const isOptional = (property.flags & ts.SymbolFlags.Optional) !== 0;
+			const name = property.getName();
+			const type = checker.getTypeOfSymbolAtLocation(property, tsNode);
+			yield {
+				type: "infer-type",
+				propName: name,
+				required: !isOptional,
+				node: propsNode,
+				types: inferRuntimeTypeInternal(type, services)
+			};
+		}
+	}
+	/**
+	* @param {Type} type
+	* @param {Services} services
+	* @returns {string[]}
+	*/
+	function inferRuntimeTypeInternal(type, services) {
+		const { checker } = services;
+		/** @type {Set<string>} */
+		const types = /* @__PURE__ */ new Set();
+		if (type.isTypeParameter()) {
+			const constraint = type.getConstraint();
+			if (constraint) for (const t of inferRuntimeTypeInternal(constraint, services)) types.add(t);
+			return [...types];
+		}
+		for (const targetType of iterateTypes(checker.getNonNullableType(type))) if (isAny(targetType) || isUnknown(targetType) || isNever(targetType) || isNull(targetType)) types.add("null");
+		else if (isStringLike(targetType)) types.add("String");
+		else if (isNumberLike(targetType) || isBigIntLike(targetType)) types.add("Number");
+		else if (isBooleanLike(targetType)) types.add("Boolean");
+		else if (isFunction(targetType)) types.add("Function");
+		else if (isArrayLikeObject(targetType) || targetType.isClassOrInterface() && ["Array", "ReadonlyArray"].includes(checker.getFullyQualifiedName(targetType.symbol))) types.add("Array");
+		else if (isObject(targetType)) types.add("Object");
+		if (types.size <= 0) types.add("null");
+		return [...types];
+	}
+	/**
+	* @param {Type} type
+	* @param {TypeScriptNode} tsNode
+	* @param {TypeNode} emitsNode Type with emits definition
+	* @param {Services} services
+	* @returns {IterableIterator<ComponentInferTypeEmit|ComponentUnknownEmit>}
+	*/
+	function* extractRuntimeEmits(type, tsNode, emitsNode, services) {
+		const { checker } = services;
+		if (isFunction(type)) for (const signature of type.getCallSignatures()) {
+			const param = signature.getParameters()[0];
+			if (!param) {
+				yield {
+					type: "unknown",
+					emitName: null,
+					node: emitsNode
+				};
+				continue;
+			}
+			const type = checker.getTypeOfSymbolAtLocation(param, tsNode);
+			for (const targetType of iterateTypes(type)) yield targetType.isStringLiteral() ? {
+				type: "infer-type",
+				emitName: targetType.value,
+				node: emitsNode
+			} : {
+				type: "unknown",
+				emitName: null,
+				node: emitsNode
+			};
+		}
+		else if (isObject(type)) for (const property of type.getProperties()) yield {
+			type: "infer-type",
+			emitName: property.getName(),
+			node: emitsNode
+		};
+		else yield {
+			type: "unknown",
+			emitName: null,
+			node: emitsNode
+		};
+	}
+	/**
+	* @param {Type} type
+	* @param {TypeNode} slotsNode Type with slots definition
+	* @returns {IterableIterator<ComponentInferTypeSlot>}
+	*/
+	function* extractRuntimeSlots(type, slotsNode) {
+		for (const property of type.getProperties()) yield {
+			type: "infer-type",
+			slotName: property.getName(),
+			node: slotsNode
+		};
+	}
+	/**
+	* @param {Type} type
+	* @returns {Iterable<Type>}
+	*/
+	function* iterateTypes(type) {
+		if (isReferenceObject(type) && type.target !== type) yield* iterateTypes(type.target);
+		else if (type.isUnion() && !isBooleanLike(type)) for (const t of type.types) yield* iterateTypes(t);
+		else yield type;
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_ts_types();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/ts-utils/typescript.js

@@ -0,0 +1,183 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/ts-utils/typescript.js
+var require_typescript = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	/**
+	* @typedef {typeof import("typescript")} TypeScript
+	* @typedef {import("typescript").Type} Type
+	* @typedef {import("typescript").ObjectType} ObjectType
+	* @typedef {import("typescript").InterfaceType} InterfaceType
+	* @typedef {import("typescript").TypeReference} TypeReference
+	* @typedef {import("typescript").UnionOrIntersectionType} UnionOrIntersectionType
+	* @typedef {import("typescript").TypeParameter} TypeParameter
+	*/
+	/** @type {TypeScript | undefined} */
+	let cacheTypeScript;
+	module.exports = {
+		getTypeScript,
+		isObject,
+		isAny,
+		isUnknown,
+		isNever,
+		isNull,
+		isFunction,
+		isArrayLikeObject,
+		isStringLike,
+		isNumberLike,
+		isBooleanLike,
+		isBigIntLike,
+		isReferenceObject,
+		extractTypeFlags,
+		extractObjectFlags
+	};
+	/**
+	* Get TypeScript instance
+	*/
+	function getTypeScript() {
+		if (cacheTypeScript) return cacheTypeScript;
+		try {
+			return cacheTypeScript = require("typescript");
+		} catch (error) {
+			if (error.code === "MODULE_NOT_FOUND") return;
+			throw error;
+		}
+	}
+	/**
+	* For debug
+	* @param {Type} tsType
+	* @returns {string[]}
+	*/
+	function extractTypeFlags(tsType) {
+		const ts = getTypeScript();
+		/** @type {string[]} */
+		const result = [];
+		const keys = Object.keys(ts.TypeFlags);
+		for (const k of keys) if ((tsType.flags & ts.TypeFlags[k]) !== 0) result.push(k);
+		return result;
+	}
+	/**
+	* For debug
+	* @param {Type} tsType
+	* @returns {string[]}
+	*/
+	function extractObjectFlags(tsType) {
+		if (!isObject(tsType)) return [];
+		const ts = getTypeScript();
+		/** @type {string[]} */
+		const result = [];
+		const keys = Object.keys(ts.ObjectFlags);
+		for (const k of keys) if ((tsType.objectFlags & ts.ObjectFlags[k]) !== 0) result.push(k);
+		return result;
+	}
+	/**
+	* Check if a given type is an object type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {tsType is ObjectType}
+	*/
+	function isObject(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.Object) !== 0;
+	}
+	/**
+	* Check if a given type is an array-like type or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isArrayLikeObject(tsType) {
+		const ts = getTypeScript();
+		return isObject(tsType) && (tsType.objectFlags & (ts.ObjectFlags.ArrayLiteral | ts.ObjectFlags.EvolvingArray | ts.ObjectFlags.Tuple)) !== 0;
+	}
+	/**
+	* Check if a given type is an any type or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isAny(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.Any) !== 0;
+	}
+	/**
+	* Check if a given type is an unknown type or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isUnknown(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.Unknown) !== 0;
+	}
+	/**
+	* Check if a given type is a never type or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isNever(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.Never) !== 0;
+	}
+	/**
+	* Check if a given type is an null type or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isNull(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.Null) !== 0;
+	}
+	/**
+	* Check if a given type is a string-like type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {boolean} `true` if the type is a string-like type.
+	*/
+	function isStringLike(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.StringLike) !== 0;
+	}
+	/**
+	* Check if a given type is an number-like type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {boolean} `true` if the type is a number-like type.
+	*/
+	function isNumberLike(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.NumberLike) !== 0;
+	}
+	/**
+	* Check if a given type is an boolean-like type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {boolean} `true` if the type is a boolean-like type.
+	*/
+	function isBooleanLike(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.BooleanLike) !== 0;
+	}
+	/**
+	* Check if a given type is an bigint-like type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {boolean} `true` if the type is a bigint-like type.
+	*/
+	function isBigIntLike(tsType) {
+		const ts = getTypeScript();
+		return (tsType.flags & ts.TypeFlags.BigIntLike) !== 0;
+	}
+	/**
+	* Check if a given type is a reference type or not.
+	* @param {Type} tsType The type to check.
+	* @returns {tsType is TypeReference} `true` if the type is a reference type.
+	*/
+	function isReferenceObject(tsType) {
+		const ts = getTypeScript();
+		return isObject(tsType) && (tsType.objectFlags & ts.ObjectFlags.Reference) !== 0;
+	}
+	/**
+	* Check if a given type is `function` or not.
+	* @param {Type} tsType The type to check.
+	*/
+	function isFunction(tsType) {
+		const ts = getTypeScript();
+		if (tsType.symbol && (tsType.symbol.flags & (ts.SymbolFlags.Function | ts.SymbolFlags.Method)) !== 0) return true;
+		return tsType.getCallSignatures().length > 0;
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_typescript();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/void-elements.js

@@ -0,0 +1,31 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/void-elements.json
+var require_void_elements = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"area",
+		"base",
+		"br",
+		"col",
+		"embed",
+		"hr",
+		"img",
+		"input",
+		"keygen",
+		"link",
+		"menuitem",
+		"meta",
+		"param",
+		"source",
+		"track",
+		"wbr"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_void_elements();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue-builtin-elements.js

@@ -0,0 +1,18 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/vue-builtin-elements.js
+var require_vue_builtin_elements = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"template",
+		"slot",
+		"component"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue_builtin_elements();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue-component-options.js

@@ -0,0 +1,78 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/vue-component-options.json
+var require_vue_component_options = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		"nuxt": [
+			"asyncData",
+			"fetch",
+			"head",
+			"key",
+			"layout",
+			"loading",
+			"middleware",
+			"scrollToTop",
+			"transition",
+			"validate",
+			"watchQuery"
+		],
+		"vue-router": [
+			"beforeRouteEnter",
+			"beforeRouteUpdate",
+			"beforeRouteLeave"
+		],
+		"vue": [
+			"data",
+			"props",
+			"propsData",
+			"computed",
+			"methods",
+			"watch",
+			"el",
+			"template",
+			"render",
+			"renderError",
+			"staticRenderFns",
+			"beforeCreate",
+			"created",
+			"beforeDestroy",
+			"destroyed",
+			"beforeMount",
+			"mounted",
+			"beforeUpdate",
+			"updated",
+			"activated",
+			"deactivated",
+			"errorCaptured",
+			"serverPrefetch",
+			"directives",
+			"components",
+			"transitions",
+			"filters",
+			"provide",
+			"inject",
+			"model",
+			"parent",
+			"mixins",
+			"name",
+			"extends",
+			"delimiters",
+			"comments",
+			"inheritAttrs",
+			"setup",
+			"emits",
+			"beforeUnmount",
+			"unmounted",
+			"renderTracked",
+			"renderTriggered"
+		]
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue_component_options();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue-reserved.js

@@ -0,0 +1,39 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/vue-reserved.json
+var require_vue_reserved = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"$data",
+		"$props",
+		"$el",
+		"$options",
+		"$parent",
+		"$root",
+		"$children",
+		"$slots",
+		"$scopedSlots",
+		"$refs",
+		"$isServer",
+		"$attrs",
+		"$listeners",
+		"$watch",
+		"$set",
+		"$delete",
+		"$on",
+		"$once",
+		"$off",
+		"$emit",
+		"$mount",
+		"$forceUpdate",
+		"$nextTick",
+		"$destroy"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue_reserved();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue2-builtin-components.js

@@ -0,0 +1,25 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/vue2-builtin-components.js
+var require_vue2_builtin_components = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"template",
+		"slot",
+		"component",
+		"Component",
+		"transition",
+		"Transition",
+		"transition-group",
+		"TransitionGroup",
+		"keep-alive",
+		"KeepAlive"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue2_builtin_components();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue3-builtin-components.js

@@ -0,0 +1,21 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+const require_vue2_builtin_components$1 = require('./vue2-builtin-components.js');
+
+//#region lib/utils/vue3-builtin-components.js
+var require_vue3_builtin_components = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		...require_vue2_builtin_components$1.default,
+		"teleport",
+		"Teleport",
+		"suspense",
+		"Suspense"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue3_builtin_components();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/utils/vue3-export-names.js

@@ -0,0 +1,376 @@
+const require_runtime = require('../_virtual/_rolldown/runtime.js');
+
+//#region lib/utils/vue3-export-names.json
+var require_vue3_export_names = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = [
+		"ComputedGetter",
+		"ComputedRef",
+		"ComputedSetter",
+		"CustomRefFactory",
+		"DebuggerEvent",
+		"DebuggerEventExtraInfo",
+		"DebuggerOptions",
+		"DeepReadonly",
+		"EffectScheduler",
+		"EffectScope",
+		"MaybeRef",
+		"MaybeRefOrGetter",
+		"Raw",
+		"Reactive",
+		"ReactiveEffect",
+		"ReactiveEffectOptions",
+		"ReactiveEffectRunner",
+		"ReactiveFlags",
+		"Ref",
+		"ShallowReactive",
+		"ShallowRef",
+		"ShallowUnwrapRef",
+		"ToRef",
+		"ToRefs",
+		"TrackOpTypes",
+		"TriggerOpTypes",
+		"UnwrapNestedRefs",
+		"UnwrapRef",
+		"WatchCallback",
+		"WatchEffect",
+		"WatchHandle",
+		"WatchSource",
+		"WatchStopHandle",
+		"WritableComputedOptions",
+		"WritableComputedRef",
+		"customRef",
+		"effect",
+		"effectScope",
+		"getCurrentScope",
+		"getCurrentWatcher",
+		"isProxy",
+		"isReactive",
+		"isReadonly",
+		"isRef",
+		"isShallow",
+		"markRaw",
+		"onScopeDispose",
+		"onWatcherCleanup",
+		"proxyRefs",
+		"reactive",
+		"readonly",
+		"ref",
+		"shallowReactive",
+		"shallowReadonly",
+		"shallowRef",
+		"stop",
+		"toRaw",
+		"toRef",
+		"toRefs",
+		"toValue",
+		"triggerRef",
+		"unref",
+		"camelize",
+		"capitalize",
+		"normalizeClass",
+		"normalizeProps",
+		"normalizeStyle",
+		"toDisplayString",
+		"toHandlerKey",
+		"computed",
+		"Slot",
+		"Slots",
+		"SlotsType",
+		"nextTick",
+		"queuePostFlushCb",
+		"ComponentPropsOptions",
+		"ComponentObjectPropsOptions",
+		"Prop",
+		"PropType",
+		"ExtractPropTypes",
+		"ExtractPublicPropTypes",
+		"ExtractDefaultPropTypes",
+		"defineProps",
+		"DefineProps",
+		"defineEmits",
+		"ComponentTypeEmits",
+		"defineExpose",
+		"defineOptions",
+		"defineSlots",
+		"ModelRef",
+		"defineModel",
+		"withDefaults",
+		"useSlots",
+		"useAttrs",
+		"ObjectEmitsOptions",
+		"EmitsOptions",
+		"EmitsToProps",
+		"ShortEmitsToObject",
+		"EmitFn",
+		"DirectiveBinding",
+		"DirectiveHook",
+		"ObjectDirective",
+		"FunctionDirective",
+		"Directive",
+		"DirectiveModifiers",
+		"DirectiveArguments",
+		"withDirectives",
+		"ComponentCustomProperties",
+		"CreateComponentPublicInstance",
+		"CreateComponentPublicInstanceWithMixins",
+		"ComponentPublicInstance",
+		"SuspenseProps",
+		"Suspense",
+		"SuspenseBoundary",
+		"RootHydrateFunction",
+		"BaseTransitionProps",
+		"TransitionHooks",
+		"TransitionState",
+		"useTransitionState",
+		"BaseTransitionPropsValidators",
+		"BaseTransition",
+		"resolveTransitionHooks",
+		"setTransitionHooks",
+		"getTransitionRawChildren",
+		"Renderer",
+		"HydrationRenderer",
+		"ElementNamespace",
+		"RootRenderFunction",
+		"RendererOptions",
+		"RendererNode",
+		"RendererElement",
+		"createRenderer",
+		"createHydrationRenderer",
+		"KeepAliveProps",
+		"KeepAlive",
+		"onActivated",
+		"onDeactivated",
+		"onBeforeMount",
+		"onMounted",
+		"onBeforeUpdate",
+		"onUpdated",
+		"onBeforeUnmount",
+		"onUnmounted",
+		"onServerPrefetch",
+		"onRenderTriggered",
+		"onRenderTracked",
+		"onErrorCaptured",
+		"ComponentCustomOptions",
+		"RenderFunction",
+		"ComponentOptionsBase",
+		"RuntimeCompilerOptions",
+		"ComponentOptions",
+		"ComponentOptionsMixin",
+		"ComputedOptions",
+		"MethodOptions",
+		"ComponentProvideOptions",
+		"ComponentInjectOptions",
+		"ComponentOptionsWithoutProps",
+		"ComponentOptionsWithArrayProps",
+		"ComponentOptionsWithObjectProps",
+		"InjectionKey",
+		"provide",
+		"inject",
+		"hasInjectionContext",
+		"PublicProps",
+		"DefineComponent",
+		"DefineSetupFnComponent",
+		"defineComponent",
+		"App",
+		"OptionMergeFunction",
+		"AppConfig",
+		"AppContext",
+		"ObjectPlugin",
+		"FunctionPlugin",
+		"Plugin",
+		"CreateAppFunction",
+		"TeleportProps",
+		"Teleport",
+		"resolveComponent",
+		"resolveDynamicComponent",
+		"resolveDirective",
+		"Fragment",
+		"Text",
+		"Comment",
+		"Static",
+		"VNodeTypes",
+		"VNodeRef",
+		"VNodeProps",
+		"VNodeArrayChildren",
+		"VNodeChild",
+		"VNodeNormalizedChildren",
+		"VNode",
+		"openBlock",
+		"setBlockTracking",
+		"createElementBlock",
+		"createBlock",
+		"isVNode",
+		"transformVNodeArgs",
+		"createBaseVNode",
+		"createVNode",
+		"guardReactiveProps",
+		"cloneVNode",
+		"createTextVNode",
+		"createStaticVNode",
+		"createCommentVNode",
+		"mergeProps",
+		"AllowedAttrs",
+		"Attrs",
+		"ComponentInstance",
+		"ComponentCustomProps",
+		"GlobalDirectives",
+		"GlobalComponents",
+		"AllowedComponentProps",
+		"FunctionalComponent",
+		"ConcreteComponent",
+		"Component",
+		"SetupContext",
+		"ComponentInternalInstance",
+		"getCurrentInstance",
+		"registerRuntimeCompiler",
+		"isRuntimeOnly",
+		"ComponentCustomElementInterface",
+		"WatchEffectOptions",
+		"WatchOptions",
+		"watchEffect",
+		"watchPostEffect",
+		"watchSyncEffect",
+		"MultiWatchSources",
+		"watch",
+		"HydrationStrategy",
+		"HydrationStrategyFactory",
+		"hydrateOnIdle",
+		"hydrateOnVisible",
+		"hydrateOnMediaQuery",
+		"hydrateOnInteraction",
+		"AsyncComponentLoader",
+		"AsyncComponentOptions",
+		"defineAsyncComponent",
+		"useModel",
+		"TemplateRef",
+		"useTemplateRef",
+		"useId",
+		"h",
+		"ssrContextKey",
+		"useSSRContext",
+		"ErrorCodes",
+		"callWithErrorHandling",
+		"callWithAsyncErrorHandling",
+		"handleError",
+		"initCustomFormatter",
+		"HMRRuntime",
+		"pushScopeId",
+		"popScopeId",
+		"withScopeId",
+		"withCtx",
+		"renderList",
+		"toHandlers",
+		"renderSlot",
+		"createSlots",
+		"withMemo",
+		"isMemoSame",
+		"LegacyConfig",
+		"CompatVue",
+		"version",
+		"warn",
+		"devtools",
+		"setDevtoolsHook",
+		"DeprecationTypes",
+		"createElementVNode",
+		"WatchOptionsBase",
+		"nodeOps",
+		"patchProp",
+		"TransitionProps",
+		"Transition",
+		"TransitionGroupProps",
+		"TransitionGroup",
+		"vShow",
+		"withModifiers",
+		"withKeys",
+		"vModelText",
+		"vModelCheckbox",
+		"vModelRadio",
+		"vModelSelect",
+		"vModelDynamic",
+		"CSSProperties",
+		"AriaAttributes",
+		"StyleValue",
+		"ClassValue",
+		"HTMLAttributes",
+		"AnchorHTMLAttributes",
+		"AreaHTMLAttributes",
+		"AudioHTMLAttributes",
+		"BaseHTMLAttributes",
+		"BlockquoteHTMLAttributes",
+		"ButtonHTMLAttributes",
+		"CanvasHTMLAttributes",
+		"ColHTMLAttributes",
+		"ColgroupHTMLAttributes",
+		"DataHTMLAttributes",
+		"DetailsHTMLAttributes",
+		"DelHTMLAttributes",
+		"DialogHTMLAttributes",
+		"EmbedHTMLAttributes",
+		"FieldsetHTMLAttributes",
+		"FormHTMLAttributes",
+		"HtmlHTMLAttributes",
+		"IframeHTMLAttributes",
+		"ImgHTMLAttributes",
+		"InsHTMLAttributes",
+		"InputTypeHTMLAttribute",
+		"InputAutoCompleteAttribute",
+		"InputHTMLAttributes",
+		"KeygenHTMLAttributes",
+		"LabelHTMLAttributes",
+		"LiHTMLAttributes",
+		"LinkHTMLAttributes",
+		"MapHTMLAttributes",
+		"MenuHTMLAttributes",
+		"MediaHTMLAttributes",
+		"MetaHTMLAttributes",
+		"MeterHTMLAttributes",
+		"QuoteHTMLAttributes",
+		"ObjectHTMLAttributes",
+		"OlHTMLAttributes",
+		"OptgroupHTMLAttributes",
+		"OptionHTMLAttributes",
+		"OutputHTMLAttributes",
+		"ParamHTMLAttributes",
+		"ProgressHTMLAttributes",
+		"ScriptHTMLAttributes",
+		"SelectHTMLAttributes",
+		"SourceHTMLAttributes",
+		"StyleHTMLAttributes",
+		"TableHTMLAttributes",
+		"TextareaHTMLAttributes",
+		"TdHTMLAttributes",
+		"ThHTMLAttributes",
+		"TimeHTMLAttributes",
+		"TrackHTMLAttributes",
+		"VideoHTMLAttributes",
+		"WebViewHTMLAttributes",
+		"SVGAttributes",
+		"IntrinsicElementAttributes",
+		"Events",
+		"ReservedProps",
+		"NativeElements",
+		"VueElementConstructor",
+		"CustomElementOptions",
+		"defineCustomElement",
+		"defineSSRCustomElement",
+		"VueElement",
+		"useHost",
+		"useShadowRoot",
+		"useCssModule",
+		"useCssVars",
+		"render",
+		"hydrate",
+		"createApp",
+		"createSSRApp",
+		"compileToFunction",
+		"compile"
+	];
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_vue3_export_names();
+  }
+});