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

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/define-model.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+
+//#region lib/rules/syntaxes/define-model.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_define_model = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	module.exports = {
+		supported: ">=3.4.0",
+		createScriptVisitor(context) {
+			return utils.defineScriptSetupVisitor(context, { onDefineModelEnter(node) {
+				context.report({
+					node,
+					messageId: "forbiddenDefineModel"
+				});
+			} });
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_define_model();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/define-options.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+
+//#region lib/rules/syntaxes/define-options.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_define_options = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	module.exports = {
+		supported: ">=3.3.0",
+		createScriptVisitor(context) {
+			const sourceCode = context.sourceCode;
+			return utils.defineScriptSetupVisitor(context, { onDefineOptionsEnter(node) {
+				context.report({
+					node,
+					messageId: "forbiddenDefineOptions",
+					fix(fixer) {
+						return fix(fixer, node);
+					}
+				});
+			} });
+			/**
+			* @param {RuleFixer} fixer
+			* @param {CallExpression} node defineOptions() node
+			*/
+			function fix(fixer, node) {
+				if (node.arguments.length === 0) return null;
+				const scriptSetup = utils.getScriptSetupElement(context);
+				if (!scriptSetup) return null;
+				if (scriptSetup.parent.children.filter(utils.isVElement).some((node) => node.name === "script" && !utils.hasAttribute(node, "setup"))) return null;
+				/** @type {ASTNode} */
+				let statement = node;
+				while (statement.parent && statement.parent.type !== "Program") statement = statement.parent;
+				/** @type {Range} */
+				const removeRange = [...statement.range];
+				if (sourceCode.lines[statement.loc.start.line - 1].slice(0, statement.loc.start.column).trim() === "") removeRange[0] -= statement.loc.start.column;
+				return [fixer.insertTextBefore(scriptSetup, `<script>\nexport default ${sourceCode.getText(node.arguments[0])}\n<\/script>\n`), fixer.removeRange(removeRange)];
+			}
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_define_options();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/define-slots.js

@@ -0,0 +1,32 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+
+//#region lib/rules/syntaxes/define-slots.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_define_slots = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	module.exports = {
+		supported: ">=3.3.0",
+		createScriptVisitor(context) {
+			return utils.defineScriptSetupVisitor(context, { onDefineSlotsEnter(node) {
+				context.report({
+					node,
+					messageId: "forbiddenDefineSlots"
+				});
+			} });
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_define_slots();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/dynamic-directive-arguments.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/dynamic-directive-arguments.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_dynamic_directive_arguments = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=2.6.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports dynamic argument node
+			* @param {VExpressionContainer} dynamicArgument node of dynamic argument
+			* @returns {void}
+			*/
+			function reportDynamicArgument(dynamicArgument) {
+				context.report({
+					node: dynamicArgument,
+					messageId: "forbiddenDynamicDirectiveArguments"
+				});
+			}
+			return { "VAttribute[directive=true] > VDirectiveKey > VExpressionContainer": reportDynamicArgument };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_dynamic_directive_arguments();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/is-attribute-with-vue-prefix.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/is-attribute-with-vue-prefix.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_is_attribute_with_vue_prefix = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=3.1.0",
+		createTemplateBodyVisitor(context) {
+			return { "VAttribute[directive=false][key.name='is']"(node) {
+				if (!node.value) return;
+				if (node.value.value.startsWith("vue:")) context.report({
+					node: node.value,
+					messageId: "forbiddenIsAttributeWithVuePrefix"
+				});
+			} };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_is_attribute_with_vue_prefix();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/scope-attribute.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/scope-attribute.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_scope_attribute = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		deprecated: "2.5.0",
+		supported: "<3.0.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports `scope` node
+			* @param {VDirectiveKey} scopeKey node of `scope`
+			* @returns {void}
+			*/
+			function reportScope(scopeKey) {
+				context.report({
+					node: scopeKey,
+					messageId: "forbiddenScopeAttribute",
+					fix: (fixer) => fixer.replaceText(scopeKey, "slot-scope")
+				});
+			}
+			return { "VAttribute[directive=true] > VDirectiveKey[name.name='scope']": reportScope };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_scope_attribute();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/script-setup.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+
+//#region lib/rules/syntaxes/script-setup.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_script_setup = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	module.exports = {
+		supported: ">=2.7.0",
+		createScriptVisitor(context) {
+			const scriptSetup = utils.getScriptSetupElement(context);
+			if (!scriptSetup) return {};
+			const reportNode = utils.getAttribute(scriptSetup, "setup") || scriptSetup.startTag;
+			return { Program() {
+				context.report({
+					node: reportNode,
+					messageId: "forbiddenScriptSetup"
+				});
+			} };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_script_setup();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/slot-attribute.js

@@ -0,0 +1,101 @@
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+const require_casing = require('../../utils/casing.js');
+const require_regexp = require('../../utils/regexp.js');
+const require_can_convert_to_v_slot$1 = require('./utils/can-convert-to-v-slot.js');
+
+//#region lib/rules/syntaxes/slot-attribute.ts
+var import_can_convert_to_v_slot = /* @__PURE__ */ require_runtime.__toESM(require_can_convert_to_v_slot$1.default);
+var import_utils = /* @__PURE__ */ require_runtime.__toESM(require_index.default);
+var slot_attribute_default = {
+	deprecated: "2.6.0",
+	supported: "<3.0.0",
+	createTemplateBodyVisitor(context) {
+		const { ignore = [], ignoreParents = [] } = context.options[0] || {};
+		const isAnyIgnored = require_regexp.toRegExpGroupMatcher(ignore);
+		const isParentIgnored = require_regexp.toRegExpGroupMatcher(ignoreParents);
+		const sourceCode = context.sourceCode;
+		const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore && sourceCode.parserServices.getTemplateBodyTokenStore();
+		/**
+		* Checks whether the given node can convert to the `v-slot`.
+		*/
+		function canConvertFromSlotToVSlot(slotAttr) {
+			if (!(0, import_can_convert_to_v_slot.default)(slotAttr.parent.parent, sourceCode, tokenStore)) return false;
+			if (!slotAttr.value) return true;
+			const slotName = slotAttr.value.value;
+			return !/[^\w\-]/u.test(slotName);
+		}
+		/**
+		* Checks whether the given node can convert to the `v-slot`.
+		*/
+		function canConvertFromVBindSlotToVSlot(slotAttr) {
+			if (!(0, import_can_convert_to_v_slot.default)(slotAttr.parent.parent, sourceCode, tokenStore)) return false;
+			if (!slotAttr.value) return true;
+			if (!slotAttr.value.expression) return false;
+			return slotAttr.value.expression.type === "Identifier";
+		}
+		/**
+		* Convert to `v-slot`.
+		*/
+		function* fixSlotToVSlot(fixer, slotAttr, slotName, isVBind) {
+			const startTag = slotAttr.parent;
+			const scopeAttr = startTag.attributes.find((attr) => attr.directive === true && attr.key.name && (attr.key.name.name === "slot-scope" || attr.key.name.name === "scope"));
+			let nameArgument = "";
+			if (slotName) nameArgument = isVBind ? `:[${slotName}]` : `:${slotName}`;
+			const scopeValue = scopeAttr && scopeAttr.value ? `=${sourceCode.getText(scopeAttr.value)}` : "";
+			const replaceText = `v-slot${nameArgument}${scopeValue}`;
+			const element = startTag.parent;
+			if (element.name === "template") {
+				yield fixer.replaceText(slotAttr || scopeAttr, replaceText);
+				if (slotAttr && scopeAttr) yield fixer.remove(scopeAttr);
+			} else {
+				yield fixer.remove(slotAttr || scopeAttr);
+				if (slotAttr && scopeAttr) yield fixer.remove(scopeAttr);
+				const vFor = startTag.attributes.find((attr) => attr.directive && attr.key.name.name === "for");
+				const vForText = vFor ? `${sourceCode.getText(vFor)} ` : "";
+				if (vFor) yield fixer.remove(vFor);
+				yield fixer.insertTextBefore(element, `<template ${vForText}${replaceText}>\n`);
+				yield fixer.insertTextAfter(element, `\n</template>`);
+			}
+		}
+		/**
+		* Reports `slot` node
+		*/
+		function reportSlot(slotAttr) {
+			const component = slotAttr.parent.parent;
+			const componentName = component.rawName;
+			if (isAnyIgnored(componentName, require_casing.pascalCase(componentName), require_casing.kebabCase(componentName))) return;
+			const parent = component.parent;
+			const parentName = import_utils.default.isVElement(parent) ? parent.rawName : null;
+			if (parentName && isParentIgnored(parentName)) return;
+			context.report({
+				node: slotAttr.key,
+				messageId: "forbiddenSlotAttribute",
+				*fix(fixer) {
+					if (!canConvertFromSlotToVSlot(slotAttr)) return;
+					yield* fixSlotToVSlot(fixer, slotAttr, slotAttr.value && slotAttr.value.value, false);
+				}
+			});
+		}
+		/**
+		* Reports `v-bind:slot` node
+		*/
+		function reportVBindSlot(slotAttr) {
+			context.report({
+				node: slotAttr.key,
+				messageId: "forbiddenSlotAttribute",
+				*fix(fixer) {
+					if (!canConvertFromVBindSlotToVSlot(slotAttr)) return;
+					yield* fixSlotToVSlot(fixer, slotAttr, slotAttr.value && slotAttr.value.expression && sourceCode.getText(slotAttr.value.expression).trim(), true);
+				}
+			});
+		}
+		return {
+			"VAttribute[directive=false][key.name='slot']": reportSlot,
+			"VAttribute[directive=true][key.name.name='bind'][key.argument.name='slot']": reportVBindSlot
+		};
+	}
+};
+
+//#endregion
+exports.default = slot_attribute_default;

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/slot-scope-attribute.js

@@ -0,0 +1,77 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_can_convert_to_v_slot$1 = require('./utils/can-convert-to-v-slot.js');
+
+//#region lib/rules/syntaxes/slot-scope-attribute.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_slot_scope_attribute = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const canConvertToVSlotForElement = require_can_convert_to_v_slot$1.default;
+	module.exports = {
+		deprecated: "2.6.0",
+		supported: ">=2.5.0 <3.0.0",
+		createTemplateBodyVisitor(context, { fixToUpgrade } = {}) {
+			const sourceCode = context.sourceCode;
+			const tokenStore = sourceCode.parserServices.getTemplateBodyTokenStore && sourceCode.parserServices.getTemplateBodyTokenStore();
+			/**
+			* Checks whether the given node can convert to the `v-slot`.
+			* @param {VStartTag} startTag node of `<element v-slot ... >`
+			* @returns {boolean} `true` if the given node can convert to the `v-slot`
+			*/
+			function canConvertToVSlot(startTag) {
+				if (!canConvertToVSlotForElement(startTag.parent, sourceCode, tokenStore)) return false;
+				if (startTag.attributes.find((attr) => attr.directive === false && attr.key.name === "slot")) return false;
+				if (startTag.attributes.find((attr) => attr.directive === true && attr.key.name.name === "bind" && attr.key.argument && attr.key.argument.type === "VIdentifier" && attr.key.argument.name === "slot")) return false;
+				return true;
+			}
+			/**
+			* Convert to `v-slot`.
+			* @param {RuleFixer} fixer fixer
+			* @param {VDirective} scopeAttr node of `slot-scope`
+			* @returns {Fix[]} fix data
+			*/
+			function fixSlotScopeToVSlot(fixer, scopeAttr) {
+				const element = scopeAttr.parent.parent;
+				const replaceText = `v-slot${scopeAttr && scopeAttr.value ? `=${sourceCode.getText(scopeAttr.value)}` : ""}`;
+				if (element.name === "template") return [fixer.replaceText(scopeAttr, replaceText)];
+				else {
+					const tokenBefore = tokenStore.getTokenBefore(scopeAttr);
+					return [
+						fixer.removeRange([tokenBefore.range[1], scopeAttr.range[1]]),
+						fixer.insertTextBefore(element, `<template ${replaceText}>\n`),
+						fixer.insertTextAfter(element, `\n</template>`)
+					];
+				}
+			}
+			/**
+			* Reports `slot-scope` node
+			* @param {VDirective} scopeAttr node of `slot-scope`
+			* @returns {void}
+			*/
+			function reportSlotScope(scopeAttr) {
+				context.report({
+					node: scopeAttr.key,
+					messageId: "forbiddenSlotScopeAttribute",
+					fix(fixer) {
+						if (!fixToUpgrade) return null;
+						const startTag = scopeAttr.parent;
+						if (!canConvertToVSlot(startTag)) return null;
+						return fixSlotScopeToVSlot(fixer, scopeAttr);
+					}
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='slot-scope']": reportSlotScope };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_slot_scope_attribute();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/style-css-vars-injection.js

@@ -0,0 +1,23 @@
+const require_index = require('../../utils/style-variables/index.js');
+
+//#region lib/rules/syntaxes/style-css-vars-injection.ts
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var style_css_vars_injection_default = {
+	supported: ">=3.0.3 || >=2.7.0 <3.0.0",
+	createScriptVisitor(context) {
+		const styleVars = require_index.getStyleVariablesContext(context);
+		if (!styleVars) return {};
+		return { Program() {
+			for (const vBind of styleVars.vBinds) context.report({
+				node: vBind,
+				messageId: "forbiddenStyleCssVarsInjection"
+			});
+		} };
+	}
+};
+
+//#endregion
+exports.default = style_css_vars_injection_default;

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/utils/can-convert-to-v-slot.js

@@ -0,0 +1,159 @@
+'use strict';
+
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../../utils/index.js');
+
+//#region lib/rules/syntaxes/utils/can-convert-to-v-slot.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_can_convert_to_v_slot = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	/**
+	* @typedef {object} SlotVForVariables
+	* @property {VForExpression} expr
+	* @property {VVariable[]} variables
+	*/
+	/**
+	* @typedef {object} SlotContext
+	* @property {VElement} element
+	* @property {VAttribute | VDirective | null} slot
+	* @property {VDirective | null} vFor
+	* @property {SlotVForVariables | null} slotVForVars
+	* @property {string} normalizedName
+	*/
+	/**
+	* Checks whether the given element can use v-slot.
+	* @param {VElement} element
+	* @param {SourceCode} sourceCode
+	* @param {ParserServices.TokenStore} tokenStore
+	*/
+	module.exports = function canConvertToVSlot(element, sourceCode, tokenStore) {
+		const ownerElement = element.parent;
+		if (ownerElement.type === "VDocumentFragment" || !utils.isCustomComponent(ownerElement) || ownerElement.name === "component") return false;
+		const slot = getSlotContext(element, sourceCode);
+		if (slot.vFor && !slot.slotVForVars) return false;
+		if (hasSameSlotDirective(ownerElement, slot, sourceCode, tokenStore)) return false;
+		return true;
+	};
+	/**
+	* @param {VElement} element
+	* @param {SourceCode} sourceCode
+	* @returns {SlotContext}
+	*/
+	function getSlotContext(element, sourceCode) {
+		const slot = utils.getAttribute(element, "slot") || utils.getDirective(element, "bind", "slot");
+		const vFor = utils.getDirective(element, "for");
+		return {
+			element,
+			slot,
+			vFor,
+			slotVForVars: getSlotVForVariableIfUsingIterationVars(slot, vFor),
+			normalizedName: getNormalizedName(slot, sourceCode)
+		};
+	}
+	/**
+	* Gets the `v-for` directive and variable that provide the variables used by the given `slot` attribute.
+	* @param {VAttribute | VDirective | null} slot The current `slot` attribute node.
+	* @param {VDirective | null} [vFor] The current `v-for` directive node.
+	* @returns { SlotVForVariables | null } The SlotVForVariables.
+	*/
+	function getSlotVForVariableIfUsingIterationVars(slot, vFor) {
+		if (!slot || !slot.directive) return null;
+		const expr = vFor && vFor.value && vFor.value.expression;
+		const variables = expr && getUsingIterationVars(slot.value, slot.parent.parent);
+		return expr && variables && variables.length > 0 ? {
+			expr,
+			variables
+		} : null;
+	}
+	/**
+	* Gets iterative variables if a given expression node is using iterative variables that the element defined.
+	* @param {VExpressionContainer|null} expression The expression node to check.
+	* @param {VElement} element The element node which has the expression.
+	* @returns {VVariable[]} The expression node is using iteration variables.
+	*/
+	function getUsingIterationVars(expression, element) {
+		const vars = [];
+		if (expression && expression.type === "VExpressionContainer") {
+			for (const { variable } of expression.references) if (variable != null && variable.kind === "v-for" && variable.id.range[0] > element.startTag.range[0] && variable.id.range[1] < element.startTag.range[1]) vars.push(variable);
+		}
+		return vars;
+	}
+	/**
+	* Get the normalized name of a given `slot` attribute node.
+	* @param {VAttribute | VDirective | null} slotAttr node of `slot`
+	* @param {SourceCode} sourceCode The source code.
+	* @returns {string} The normalized name.
+	*/
+	function getNormalizedName(slotAttr, sourceCode) {
+		if (!slotAttr) return "default";
+		if (!slotAttr.directive) return slotAttr.value ? slotAttr.value.value : "default";
+		return slotAttr.value ? `[${sourceCode.getText(slotAttr.value)}]` : "[null]";
+	}
+	/**
+	* Checks whether parent element has the same slot as the given slot.
+	* @param {VElement} ownerElement The parent element.
+	* @param {SlotContext} targetSlot The SlotContext with a slot to check if they are the same.
+	* @param {SourceCode} sourceCode
+	* @param {ParserServices.TokenStore} tokenStore
+	*/
+	function hasSameSlotDirective(ownerElement, targetSlot, sourceCode, tokenStore) {
+		for (const group of utils.iterateChildElementsChains(ownerElement)) {
+			if (group.includes(targetSlot.element)) continue;
+			for (const childElement of group) {
+				const slot = getSlotContext(childElement, sourceCode);
+				if (!targetSlot.slotVForVars || !slot.slotVForVars) {
+					if (!targetSlot.slotVForVars && !slot.slotVForVars && targetSlot.normalizedName === slot.normalizedName) return true;
+					continue;
+				}
+				if (equalSlotVForVariables(targetSlot.slotVForVars, slot.slotVForVars, tokenStore)) return true;
+			}
+		}
+		return false;
+	}
+	/**
+	* Determines whether the two given `v-slot` variables are considered to be equal.
+	* @param {SlotVForVariables} a First element.
+	* @param {SlotVForVariables} b Second element.
+	* @param {ParserServices.TokenStore} tokenStore The token store.
+	* @returns {boolean} `true` if the elements are considered to be equal.
+	*/
+	function equalSlotVForVariables(a, b, tokenStore) {
+		if (a.variables.length !== b.variables.length) return false;
+		if (!equal(a.expr.right, b.expr.right)) return false;
+		const checkedVarNames = /* @__PURE__ */ new Set();
+		const len = Math.min(a.expr.left.length, b.expr.left.length);
+		for (let index = 0; index < len; index++) {
+			const aPtn = a.expr.left[index];
+			const bPtn = b.expr.left[index];
+			const aVar = a.variables.find((v) => aPtn.range[0] <= v.id.range[0] && v.id.range[1] <= aPtn.range[1]);
+			const bVar = b.variables.find((v) => bPtn.range[0] <= v.id.range[0] && v.id.range[1] <= bPtn.range[1]);
+			if (aVar && bVar) {
+				if (aVar.id.name !== bVar.id.name) return false;
+				if (!equal(aPtn, bPtn)) return false;
+				checkedVarNames.add(aVar.id.name);
+			} else if (aVar || bVar) return false;
+		}
+		return a.variables.every((v) => checkedVarNames.has(v.id.name) || b.variables.some((bv) => v.id.name === bv.id.name));
+		/**
+		* Determines whether the two given nodes are considered to be equal.
+		* @param {ASTNode} a First node.
+		* @param {ASTNode} b Second node.
+		* @returns {boolean} `true` if the nodes are considered to be equal.
+		*/
+		function equal(a, b) {
+			if (a.type !== b.type) return false;
+			return utils.equalTokens(a, b, tokenStore);
+		}
+	}
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_can_convert_to_v_slot();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-bind-attr-modifier.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-bind-attr-modifier.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_bind_attr_modifier = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=3.2.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports `v-bind.attr` node
+			* @param { VIdentifier } mod node of `v-bind.attr`
+			* @returns {void}
+			*/
+			function report(mod) {
+				context.report({
+					node: mod,
+					messageId: "forbiddenVBindAttrModifier"
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='bind']"(node) {
+				const attrMod = node.key.modifiers.find((m) => m.name === "attr");
+				if (attrMod) report(attrMod);
+			} };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_bind_attr_modifier();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-bind-prop-modifier-shorthand.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-bind-prop-modifier-shorthand.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_bind_prop_modifier_shorthand = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=3.2.0 || >=2.6.0-beta.1 <=2.6.0-beta.3",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports `.prop` shorthand node
+			* @param { VDirectiveKey & { argument: VIdentifier } } bindPropKey node of `.prop` shorthand
+			* @returns {void}
+			*/
+			function reportPropModifierShorthand(bindPropKey) {
+				context.report({
+					node: bindPropKey,
+					messageId: "forbiddenVBindPropModifierShorthand",
+					fix: (fixer) => fixer.replaceText(bindPropKey, `:${bindPropKey.argument.rawName}.prop`)
+				});
+			}
+			return { "VAttribute[directive=true] > VDirectiveKey[name.name='bind'][name.rawName='.']": reportPropModifierShorthand };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_bind_prop_modifier_shorthand();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-bind-same-name-shorthand.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+const require_index = require('../../utils/index.js');
+
+//#region lib/rules/syntaxes/v-bind-same-name-shorthand.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_bind_same_name_shorthand = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const utils = require_index.default;
+	module.exports = {
+		supported: ">=3.4.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Verify the directive node
+			* @param {VDirective} node The directive node to check
+			* @returns {void}
+			*/
+			function checkDirective(node) {
+				if (utils.isVBindSameNameShorthand(node)) context.report({
+					node,
+					messageId: "forbiddenVBindSameNameShorthand",
+					fix: (fixer) => fixer.insertTextAfter(node, `="${node.value.expression.name}"`)
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='bind']": checkDirective };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_bind_same_name_shorthand();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-is.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-is.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_is = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		deprecated: "3.1.0",
+		supported: ">=3.0.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports `v-is` node
+			* @param {VDirective} vIsAttr node of `v-is`
+			* @returns {void}
+			*/
+			function reportVIs(vIsAttr) {
+				context.report({
+					node: vIsAttr.key,
+					messageId: "forbiddenVIs"
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='is']": reportVIs };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_is();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-memo.js

@@ -0,0 +1,36 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-memo.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_memo = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=3.2.0",
+		createTemplateBodyVisitor(context) {
+			/**
+			* Reports `v-is` node
+			* @param {VDirective} vMemoAttr node of `v-is`
+			* @returns {void}
+			*/
+			function reportVMemo(vMemoAttr) {
+				context.report({
+					node: vMemoAttr.key,
+					messageId: "forbiddenVMemo"
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='memo']": reportVMemo };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_memo();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-model-argument.js

@@ -0,0 +1,30 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-model-argument.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_model_argument = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	module.exports = {
+		supported: ">=3.0.0",
+		createTemplateBodyVisitor(context) {
+			return { "VAttribute[directive=true] > VDirectiveKey[name.name='model'][argument!=null]"(node) {
+				context.report({
+					node: node.argument,
+					messageId: "forbiddenVModelArgument"
+				});
+			} };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_model_argument();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-model-custom-modifiers.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-model-custom-modifiers.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_model_custom_modifiers = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	const BUILTIN_MODIFIERS = new Set([
+		"lazy",
+		"number",
+		"trim"
+	]);
+	module.exports = {
+		supported: ">=3.0.0",
+		createTemplateBodyVisitor(context) {
+			return { "VAttribute[directive=true] > VDirectiveKey[name.name='model'][modifiers.length>0]"(node) {
+				for (const modifier of node.modifiers) if (!BUILTIN_MODIFIERS.has(modifier.name)) context.report({
+					node: modifier,
+					messageId: "forbiddenVModelCustomModifiers"
+				});
+			} };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_model_custom_modifiers();
+  }
+});

frontend/node_modules/eslint-plugin-vue/dist/rules/syntaxes/v-slot.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const require_runtime = require('../../_virtual/_rolldown/runtime.js');
+
+//#region lib/rules/syntaxes/v-slot.js
+/**
+* @author Yosuke Ota
+* See LICENSE file in root directory for full license.
+*/
+var require_v_slot = /* @__PURE__ */ require_runtime.__commonJSMin(((exports, module) => {
+	/**
+	* Checks whether the given node can convert to the `slot`.
+	* @param {VDirective} vSlotAttr node of `v-slot`
+	* @returns {boolean} `true` if the given node can convert to the `slot`
+	*/
+	function canConvertToSlot(vSlotAttr) {
+		return vSlotAttr.parent.parent.name === "template";
+	}
+	module.exports = {
+		supported: ">=2.6.0",
+		createTemplateBodyVisitor(context) {
+			const sourceCode = context.sourceCode;
+			/**
+			* Convert to `slot` and `slot-scope`.
+			* @param {RuleFixer} fixer fixer
+			* @param {VDirective} vSlotAttr node of `v-slot`
+			* @returns {null|Fix} fix data
+			*/
+			function fixVSlotToSlot(fixer, vSlotAttr) {
+				const key = vSlotAttr.key;
+				if (key.modifiers.length > 0) return null;
+				const attrs = [];
+				const argument = key.argument;
+				if (argument) if (argument.type === "VIdentifier") {
+					const name = argument.rawName;
+					attrs.push(`slot="${name}"`);
+				} else if (argument.type === "VExpressionContainer" && argument.expression) {
+					const expression = sourceCode.getText(argument.expression);
+					attrs.push(`:slot="${expression}"`);
+				} else return null;
+				const scopedValueNode = vSlotAttr.value;
+				if (scopedValueNode) attrs.push(`slot-scope=${sourceCode.getText(scopedValueNode)}`);
+				if (attrs.length === 0) attrs.push("slot");
+				return fixer.replaceText(vSlotAttr, attrs.join(" "));
+			}
+			/**
+			* Reports `v-slot` node
+			* @param {VDirective} vSlotAttr node of `v-slot`
+			* @returns {void}
+			*/
+			function reportVSlot(vSlotAttr) {
+				context.report({
+					node: vSlotAttr.key,
+					messageId: "forbiddenVSlot",
+					fix(fixer) {
+						if (!canConvertToSlot(vSlotAttr)) return null;
+						return fixVSlotToSlot(fixer, vSlotAttr);
+					}
+				});
+			}
+			return { "VAttribute[directive=true][key.name.name='slot']": reportVSlot };
+		}
+	};
+}));
+
+//#endregion
+Object.defineProperty(exports, 'default', {
+  enumerable: true,
+  get: function () {
+    return require_v_slot();
+  }
+});