build: update npm install command to use --legacy-peer-deps

This change modifies the build scripts to use --legacy-peer-deps flag when installing npm dependencies to resolve potential peer dependency conflicts during the build process. The change is applied to both bash (build.sh) and batch (build.bat) build scripts.

frontend/node_modules/eslint/lib/cli-engine/file-enumerator.js

@@ -34,15 +34,18 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const fs = require("node:fs");
-const path = require("node:path");
+const fs = require("fs");
+const path = require("path");
 const getGlobParent = require("glob-parent");
 const isGlob = require("is-glob");
 const escapeRegExp = require("escape-string-regexp");
 const { Minimatch } = require("minimatch");
 
 const {
-	Legacy: { IgnorePattern, CascadingConfigArrayFactory },
+    Legacy: {
+        IgnorePattern,
+        CascadingConfigArrayFactory
+    }
 } = require("@eslint/eslintrc");
 const debug = require("debug")("eslint:file-enumerator");
 
@@ -51,7 +54,7 @@ const debug = require("debug")("eslint:file-enumerator");
 //------------------------------------------------------------------------------
 
 const minimatchOpts = { dot: true, matchBase: true };
-const dotfilesPattern = /(?:^\.|[/\\]\.)[^/\\.].*/u;
+const dotfilesPattern = /(?:(?:^\.)|(?:[/\\]\.))[^/\\.].*/u;
 const NONE = 0;
 const IGNORED_SILENTLY = 1;
 const IGNORED = 2;
@@ -105,7 +108,7 @@ const internalSlotsMap = new WeakMap();
  * @returns {boolean} `true` if the string is a glob pattern.
  */
 function isGlobPattern(pattern) {
-	return isGlob(path.sep === "\\" ? pattern.replace(/\\/gu, "/") : pattern);
+    return isGlob(path.sep === "\\" ? pattern.replace(/\\/gu, "/") : pattern);
 }
 
 /**
@@ -116,15 +119,16 @@ function isGlobPattern(pattern) {
  * @private
  */
 function statSafeSync(filePath) {
-	try {
-		return fs.statSync(filePath);
-	} catch (error) {
-		/* c8 ignore next */
-		if (error.code !== "ENOENT") {
-			throw error;
-		}
-		return null;
-	}
+    try {
+        return fs.statSync(filePath);
+    } catch (error) {
+
+        /* c8 ignore next */
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+        return null;
+    }
 }
 
 /**
@@ -135,15 +139,16 @@ function statSafeSync(filePath) {
  * @private
  */
 function readdirSafeSync(directoryPath) {
-	try {
-		return fs.readdirSync(directoryPath, { withFileTypes: true });
-	} catch (error) {
-		/* c8 ignore next */
-		if (error.code !== "ENOENT") {
-			throw error;
-		}
-		return [];
-	}
+    try {
+        return fs.readdirSync(directoryPath, { withFileTypes: true });
+    } catch (error) {
+
+        /* c8 ignore next */
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+        return [];
+    }
 }
 
 /**
@@ -152,45 +157,50 @@ function readdirSafeSync(directoryPath) {
  * @returns {RegExp | null} The created `RegExp` object or null.
  */
 function createExtensionRegExp(extensions) {
-	if (extensions) {
-		const normalizedExts = extensions.map(ext =>
-			escapeRegExp(ext.startsWith(".") ? ext.slice(1) : ext),
-		);
+    if (extensions) {
+        const normalizedExts = extensions.map(ext => escapeRegExp(
+            ext.startsWith(".")
+                ? ext.slice(1)
+                : ext
+        ));
 
-		return new RegExp(`.\\.(?:${normalizedExts.join("|")})$`, "u");
-	}
-	return null;
+        return new RegExp(
+            `.\\.(?:${normalizedExts.join("|")})$`,
+            "u"
+        );
+    }
+    return null;
 }
 
 /**
  * The error type when no files match a glob.
  */
 class NoFilesFoundError extends Error {
-	/**
-	 * @param {string} pattern The glob pattern which was not found.
-	 * @param {boolean} globDisabled If `true` then the pattern was a glob pattern, but glob was disabled.
-	 */
-	constructor(pattern, globDisabled) {
-		super(
-			`No files matching '${pattern}' were found${globDisabled ? " (glob was disabled)" : ""}.`,
-		);
-		this.messageTemplate = "file-not-found";
-		this.messageData = { pattern, globDisabled };
-	}
+
+    /**
+     * @param {string} pattern The glob pattern which was not found.
+     * @param {boolean} globDisabled If `true` then the pattern was a glob pattern, but glob was disabled.
+     */
+    constructor(pattern, globDisabled) {
+        super(`No files matching '${pattern}' were found${globDisabled ? " (glob was disabled)" : ""}.`);
+        this.messageTemplate = "file-not-found";
+        this.messageData = { pattern, globDisabled };
+    }
 }
 
 /**
  * The error type when there are files matched by a glob, but all of them have been ignored.
  */
 class AllFilesIgnoredError extends Error {
-	/**
-	 * @param {string} pattern The glob pattern which was not found.
-	 */
-	constructor(pattern) {
-		super(`All files matched by '${pattern}' are ignored.`);
-		this.messageTemplate = "all-files-ignored";
-		this.messageData = { pattern };
-	}
+
+    /**
+     * @param {string} pattern The glob pattern which was not found.
+     */
+    constructor(pattern) {
+        super(`All files matched by '${pattern}' are ignored.`);
+        this.messageTemplate = "all-files-ignored";
+        this.messageData = { pattern };
+    }
 }
 
 /**
@@ -198,340 +208,336 @@ class AllFilesIgnoredError extends Error {
  * matched by given glob patterns and that configuration.
  */
 class FileEnumerator {
-	/**
-	 * Initialize this enumerator.
-	 * @param {FileEnumeratorOptions} options The options.
-	 */
-	constructor({
-		cwd = process.cwd(),
-		configArrayFactory = new CascadingConfigArrayFactory({
-			cwd,
-			getEslintRecommendedConfig: () =>
-				require("@eslint/js").configs.recommended,
-			getEslintAllConfig: () => require("@eslint/js").configs.all,
-		}),
-		extensions = null,
-		globInputPaths = true,
-		errorOnUnmatchedPattern = true,
-		ignore = true,
-	} = {}) {
-		internalSlotsMap.set(this, {
-			configArrayFactory,
-			cwd,
-			defaultIgnores: IgnorePattern.createDefaultIgnore(cwd),
-			extensionRegExp: createExtensionRegExp(extensions),
-			globInputPaths,
-			errorOnUnmatchedPattern,
-			ignoreFlag: ignore,
-		});
-	}
 
-	/**
-	 * Check if a given file is target or not.
-	 * @param {string} filePath The path to a candidate file.
-	 * @param {ConfigArray} [providedConfig] Optional. The configuration for the file.
-	 * @returns {boolean} `true` if the file is a target.
-	 */
-	isTargetPath(filePath, providedConfig) {
-		const { configArrayFactory, extensionRegExp } =
-			internalSlotsMap.get(this);
+    /**
+     * Initialize this enumerator.
+     * @param {FileEnumeratorOptions} options The options.
+     */
+    constructor({
+        cwd = process.cwd(),
+        configArrayFactory = new CascadingConfigArrayFactory({
+            cwd,
+            getEslintRecommendedConfig: () => require("@eslint/js").configs.recommended,
+            getEslintAllConfig: () => require("@eslint/js").configs.all
+        }),
+        extensions = null,
+        globInputPaths = true,
+        errorOnUnmatchedPattern = true,
+        ignore = true
+    } = {}) {
+        internalSlotsMap.set(this, {
+            configArrayFactory,
+            cwd,
+            defaultIgnores: IgnorePattern.createDefaultIgnore(cwd),
+            extensionRegExp: createExtensionRegExp(extensions),
+            globInputPaths,
+            errorOnUnmatchedPattern,
+            ignoreFlag: ignore
+        });
+    }
 
-		// If `--ext` option is present, use it.
-		if (extensionRegExp) {
-			return extensionRegExp.test(filePath);
-		}
+    /**
+     * Check if a given file is target or not.
+     * @param {string} filePath The path to a candidate file.
+     * @param {ConfigArray} [providedConfig] Optional. The configuration for the file.
+     * @returns {boolean} `true` if the file is a target.
+     */
+    isTargetPath(filePath, providedConfig) {
+        const {
+            configArrayFactory,
+            extensionRegExp
+        } = internalSlotsMap.get(this);
 
-		// `.js` file is target by default.
-		if (filePath.endsWith(".js")) {
-			return true;
-		}
+        // If `--ext` option is present, use it.
+        if (extensionRegExp) {
+            return extensionRegExp.test(filePath);
+        }
 
-		// use `overrides[].files` to check additional targets.
-		const config =
-			providedConfig ||
-			configArrayFactory.getConfigArrayForFile(filePath, {
-				ignoreNotFoundError: true,
-			});
+        // `.js` file is target by default.
+        if (filePath.endsWith(".js")) {
+            return true;
+        }
 
-		return config.isAdditionalTargetPath(filePath);
-	}
+        // use `overrides[].files` to check additional targets.
+        const config =
+            providedConfig ||
+            configArrayFactory.getConfigArrayForFile(
+                filePath,
+                { ignoreNotFoundError: true }
+            );
 
-	/**
-	 * Iterate files which are matched by given glob patterns.
-	 * @param {string|string[]} patternOrPatterns The glob patterns to iterate files.
-	 * @throws {NoFilesFoundError|AllFilesIgnoredError} On an unmatched pattern.
-	 * @returns {IterableIterator<FileAndConfig>} The found files.
-	 */
-	*iterateFiles(patternOrPatterns) {
-		const { globInputPaths, errorOnUnmatchedPattern } =
-			internalSlotsMap.get(this);
-		const patterns = Array.isArray(patternOrPatterns)
-			? patternOrPatterns
-			: [patternOrPatterns];
+        return config.isAdditionalTargetPath(filePath);
+    }
 
-		debug("Start to iterate files: %o", patterns);
+    /**
+     * Iterate files which are matched by given glob patterns.
+     * @param {string|string[]} patternOrPatterns The glob patterns to iterate files.
+     * @throws {NoFilesFoundError|AllFilesIgnoredError} On an unmatched pattern.
+     * @returns {IterableIterator<FileAndConfig>} The found files.
+     */
+    *iterateFiles(patternOrPatterns) {
+        const { globInputPaths, errorOnUnmatchedPattern } = internalSlotsMap.get(this);
+        const patterns = Array.isArray(patternOrPatterns)
+            ? patternOrPatterns
+            : [patternOrPatterns];
 
-		// The set of paths to remove duplicate.
-		const set = new Set();
+        debug("Start to iterate files: %o", patterns);
 
-		for (const pattern of patterns) {
-			let foundRegardlessOfIgnored = false;
-			let found = false;
+        // The set of paths to remove duplicate.
+        const set = new Set();
 
-			// Skip empty string.
-			if (!pattern) {
-				continue;
-			}
+        for (const pattern of patterns) {
+            let foundRegardlessOfIgnored = false;
+            let found = false;
 
-			// Iterate files of this pattern.
-			for (const { config, filePath, flag } of this._iterateFiles(
-				pattern,
-			)) {
-				foundRegardlessOfIgnored = true;
-				if (flag === IGNORED_SILENTLY) {
-					continue;
-				}
-				found = true;
+            // Skip empty string.
+            if (!pattern) {
+                continue;
+            }
 
-				// Remove duplicate paths while yielding paths.
-				if (!set.has(filePath)) {
-					set.add(filePath);
-					yield {
-						config,
-						filePath,
-						ignored: flag === IGNORED,
-					};
-				}
-			}
+            // Iterate files of this pattern.
+            for (const { config, filePath, flag } of this._iterateFiles(pattern)) {
+                foundRegardlessOfIgnored = true;
+                if (flag === IGNORED_SILENTLY) {
+                    continue;
+                }
+                found = true;
 
-			// Raise an error if any files were not found.
-			if (errorOnUnmatchedPattern) {
-				if (!foundRegardlessOfIgnored) {
-					throw new NoFilesFoundError(
-						pattern,
-						!globInputPaths && isGlob(pattern),
-					);
-				}
-				if (!found) {
-					throw new AllFilesIgnoredError(pattern);
-				}
-			}
-		}
+                // Remove duplicate paths while yielding paths.
+                if (!set.has(filePath)) {
+                    set.add(filePath);
+                    yield {
+                        config,
+                        filePath,
+                        ignored: flag === IGNORED
+                    };
+                }
+            }
 
-		debug(`Complete iterating files: ${JSON.stringify(patterns)}`);
-	}
+            // Raise an error if any files were not found.
+            if (errorOnUnmatchedPattern) {
+                if (!foundRegardlessOfIgnored) {
+                    throw new NoFilesFoundError(
+                        pattern,
+                        !globInputPaths && isGlob(pattern)
+                    );
+                }
+                if (!found) {
+                    throw new AllFilesIgnoredError(pattern);
+                }
+            }
+        }
 
-	/**
-	 * Iterate files which are matched by a given glob pattern.
-	 * @param {string} pattern The glob pattern to iterate files.
-	 * @returns {IterableIterator<FileEntry>} The found files.
-	 */
-	_iterateFiles(pattern) {
-		const { cwd, globInputPaths } = internalSlotsMap.get(this);
-		const absolutePath = path.resolve(cwd, pattern);
-		const isDot = dotfilesPattern.test(pattern);
-		const stat = statSafeSync(absolutePath);
+        debug(`Complete iterating files: ${JSON.stringify(patterns)}`);
+    }
 
-		if (stat && stat.isDirectory()) {
-			return this._iterateFilesWithDirectory(absolutePath, isDot);
-		}
-		if (stat && stat.isFile()) {
-			return this._iterateFilesWithFile(absolutePath);
-		}
-		if (globInputPaths && isGlobPattern(pattern)) {
-			return this._iterateFilesWithGlob(pattern, isDot);
-		}
+    /**
+     * Iterate files which are matched by a given glob pattern.
+     * @param {string} pattern The glob pattern to iterate files.
+     * @returns {IterableIterator<FileEntry>} The found files.
+     */
+    _iterateFiles(pattern) {
+        const { cwd, globInputPaths } = internalSlotsMap.get(this);
+        const absolutePath = path.resolve(cwd, pattern);
+        const isDot = dotfilesPattern.test(pattern);
+        const stat = statSafeSync(absolutePath);
 
-		return [];
-	}
+        if (stat && stat.isDirectory()) {
+            return this._iterateFilesWithDirectory(absolutePath, isDot);
+        }
+        if (stat && stat.isFile()) {
+            return this._iterateFilesWithFile(absolutePath);
+        }
+        if (globInputPaths && isGlobPattern(pattern)) {
+            return this._iterateFilesWithGlob(pattern, isDot);
+        }
 
-	/**
-	 * Iterate a file which is matched by a given path.
-	 * @param {string} filePath The path to the target file.
-	 * @returns {IterableIterator<FileEntry>} The found files.
-	 * @private
-	 */
-	_iterateFilesWithFile(filePath) {
-		debug(`File: ${filePath}`);
+        return [];
+    }
 
-		const { configArrayFactory } = internalSlotsMap.get(this);
-		const config = configArrayFactory.getConfigArrayForFile(filePath);
-		const ignored = this._isIgnoredFile(filePath, { config, direct: true });
-		const flag = ignored ? IGNORED : NONE;
+    /**
+     * Iterate a file which is matched by a given path.
+     * @param {string} filePath The path to the target file.
+     * @returns {IterableIterator<FileEntry>} The found files.
+     * @private
+     */
+    _iterateFilesWithFile(filePath) {
+        debug(`File: ${filePath}`);
 
-		return [{ config, filePath, flag }];
-	}
+        const { configArrayFactory } = internalSlotsMap.get(this);
+        const config = configArrayFactory.getConfigArrayForFile(filePath);
+        const ignored = this._isIgnoredFile(filePath, { config, direct: true });
+        const flag = ignored ? IGNORED : NONE;
 
-	/**
-	 * Iterate files in a given path.
-	 * @param {string} directoryPath The path to the target directory.
-	 * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.
-	 * @returns {IterableIterator<FileEntry>} The found files.
-	 * @private
-	 */
-	_iterateFilesWithDirectory(directoryPath, dotfiles) {
-		debug(`Directory: ${directoryPath}`);
+        return [{ config, filePath, flag }];
+    }
 
-		return this._iterateFilesRecursive(directoryPath, {
-			dotfiles,
-			recursive: true,
-			selector: null,
-		});
-	}
+    /**
+     * Iterate files in a given path.
+     * @param {string} directoryPath The path to the target directory.
+     * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.
+     * @returns {IterableIterator<FileEntry>} The found files.
+     * @private
+     */
+    _iterateFilesWithDirectory(directoryPath, dotfiles) {
+        debug(`Directory: ${directoryPath}`);
 
-	/**
-	 * Iterate files which are matched by a given glob pattern.
-	 * @param {string} pattern The glob pattern to iterate files.
-	 * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.
-	 * @returns {IterableIterator<FileEntry>} The found files.
-	 * @private
-	 */
-	_iterateFilesWithGlob(pattern, dotfiles) {
-		debug(`Glob: ${pattern}`);
+        return this._iterateFilesRecursive(
+            directoryPath,
+            { dotfiles, recursive: true, selector: null }
+        );
+    }
 
-		const { cwd } = internalSlotsMap.get(this);
-		const directoryPath = path.resolve(cwd, getGlobParent(pattern));
-		const absolutePath = path.resolve(cwd, pattern);
-		const globPart = absolutePath.slice(directoryPath.length + 1);
+    /**
+     * Iterate files which are matched by a given glob pattern.
+     * @param {string} pattern The glob pattern to iterate files.
+     * @param {boolean} dotfiles If `true` then it doesn't skip dot files by default.
+     * @returns {IterableIterator<FileEntry>} The found files.
+     * @private
+     */
+    _iterateFilesWithGlob(pattern, dotfiles) {
+        debug(`Glob: ${pattern}`);
 
-		/*
-		 * recursive if there are `**` or path separators in the glob part.
-		 * Otherwise, patterns such as `src/*.js`, it doesn't need recursive.
-		 */
-		const recursive = /\*\*|\/|\\/u.test(globPart);
-		const selector = new Minimatch(absolutePath, minimatchOpts);
+        const { cwd } = internalSlotsMap.get(this);
+        const directoryPath = path.resolve(cwd, getGlobParent(pattern));
+        const absolutePath = path.resolve(cwd, pattern);
+        const globPart = absolutePath.slice(directoryPath.length + 1);
 
-		debug(`recursive? ${recursive}`);
+        /*
+         * recursive if there are `**` or path separators in the glob part.
+         * Otherwise, patterns such as `src/*.js`, it doesn't need recursive.
+         */
+        const recursive = /\*\*|\/|\\/u.test(globPart);
+        const selector = new Minimatch(absolutePath, minimatchOpts);
 
-		return this._iterateFilesRecursive(directoryPath, {
-			dotfiles,
-			recursive,
-			selector,
-		});
-	}
+        debug(`recursive? ${recursive}`);
 
-	/**
-	 * Iterate files in a given path.
-	 * @param {string} directoryPath The path to the target directory.
-	 * @param {Object} options The options to iterate files.
-	 * @param {boolean} [options.dotfiles] If `true` then it doesn't skip dot files by default.
-	 * @param {boolean} [options.recursive] If `true` then it dives into sub directories.
-	 * @param {InstanceType<Minimatch>} [options.selector] The matcher to choose files.
-	 * @returns {IterableIterator<FileEntry>} The found files.
-	 * @private
-	 */
-	*_iterateFilesRecursive(directoryPath, options) {
-		debug(`Enter the directory: ${directoryPath}`);
-		const { configArrayFactory } = internalSlotsMap.get(this);
+        return this._iterateFilesRecursive(
+            directoryPath,
+            { dotfiles, recursive, selector }
+        );
+    }
 
-		/** @type {ConfigArray|null} */
-		let config = null;
+    /**
+     * Iterate files in a given path.
+     * @param {string} directoryPath The path to the target directory.
+     * @param {Object} options The options to iterate files.
+     * @param {boolean} [options.dotfiles] If `true` then it doesn't skip dot files by default.
+     * @param {boolean} [options.recursive] If `true` then it dives into sub directories.
+     * @param {InstanceType<Minimatch>} [options.selector] The matcher to choose files.
+     * @returns {IterableIterator<FileEntry>} The found files.
+     * @private
+     */
+    *_iterateFilesRecursive(directoryPath, options) {
+        debug(`Enter the directory: ${directoryPath}`);
+        const { configArrayFactory } = internalSlotsMap.get(this);
 
-		// Enumerate the files of this directory.
-		for (const entry of readdirSafeSync(directoryPath)) {
-			const filePath = path.join(directoryPath, entry.name);
-			const fileInfo = entry.isSymbolicLink()
-				? statSafeSync(filePath)
-				: entry;
+        /** @type {ConfigArray|null} */
+        let config = null;
 
-			if (!fileInfo) {
-				continue;
-			}
+        // Enumerate the files of this directory.
+        for (const entry of readdirSafeSync(directoryPath)) {
+            const filePath = path.join(directoryPath, entry.name);
+            const fileInfo = entry.isSymbolicLink() ? statSafeSync(filePath) : entry;
 
-			// Check if the file is matched.
-			if (fileInfo.isFile()) {
-				if (!config) {
-					config = configArrayFactory.getConfigArrayForFile(
-						filePath,
+            if (!fileInfo) {
+                continue;
+            }
 
-						/*
-						 * We must ignore `ConfigurationNotFoundError` at this
-						 * point because we don't know if target files exist in
-						 * this directory.
-						 */
-						{ ignoreNotFoundError: true },
-					);
-				}
-				const matched = options.selector
-					? // Started with a glob pattern; choose by the pattern.
-						options.selector.match(filePath)
-					: // Started with a directory path; choose by file extensions.
-						this.isTargetPath(filePath, config);
+            // Check if the file is matched.
+            if (fileInfo.isFile()) {
+                if (!config) {
+                    config = configArrayFactory.getConfigArrayForFile(
+                        filePath,
 
-				if (matched) {
-					const ignored = this._isIgnoredFile(filePath, {
-						...options,
-						config,
-					});
-					const flag = ignored ? IGNORED_SILENTLY : NONE;
+                        /*
+                         * We must ignore `ConfigurationNotFoundError` at this
+                         * point because we don't know if target files exist in
+                         * this directory.
+                         */
+                        { ignoreNotFoundError: true }
+                    );
+                }
+                const matched = options.selector
 
-					debug(
-						`Yield: ${entry.name}${ignored ? " but ignored" : ""}`,
-					);
-					yield {
-						config: configArrayFactory.getConfigArrayForFile(
-							filePath,
-						),
-						filePath,
-						flag,
-					};
-				} else {
-					debug(`Didn't match: ${entry.name}`);
-				}
+                    // Started with a glob pattern; choose by the pattern.
+                    ? options.selector.match(filePath)
 
-				// Dive into the sub directory.
-			} else if (options.recursive && fileInfo.isDirectory()) {
-				if (!config) {
-					config = configArrayFactory.getConfigArrayForFile(
-						filePath,
-						{ ignoreNotFoundError: true },
-					);
-				}
-				const ignored = this._isIgnoredFile(filePath + path.sep, {
-					...options,
-					config,
-				});
+                    // Started with a directory path; choose by file extensions.
+                    : this.isTargetPath(filePath, config);
 
-				if (!ignored) {
-					yield* this._iterateFilesRecursive(filePath, options);
-				}
-			}
-		}
+                if (matched) {
+                    const ignored = this._isIgnoredFile(filePath, { ...options, config });
+                    const flag = ignored ? IGNORED_SILENTLY : NONE;
 
-		debug(`Leave the directory: ${directoryPath}`);
-	}
+                    debug(`Yield: ${entry.name}${ignored ? " but ignored" : ""}`);
+                    yield {
+                        config: configArrayFactory.getConfigArrayForFile(filePath),
+                        filePath,
+                        flag
+                    };
+                } else {
+                    debug(`Didn't match: ${entry.name}`);
+                }
 
-	/**
-	 * Check if a given file should be ignored.
-	 * @param {string} filePath The path to a file to check.
-	 * @param {Object} options Options
-	 * @param {ConfigArray} [options.config] The config for this file.
-	 * @param {boolean} [options.dotfiles] If `true` then this is not ignore dot files by default.
-	 * @param {boolean} [options.direct] If `true` then this is a direct specified file.
-	 * @returns {boolean} `true` if the file should be ignored.
-	 * @private
-	 */
-	_isIgnoredFile(
-		filePath,
-		{ config: providedConfig, dotfiles = false, direct = false },
-	) {
-		const { configArrayFactory, defaultIgnores, ignoreFlag } =
-			internalSlotsMap.get(this);
+            // Dive into the sub directory.
+            } else if (options.recursive && fileInfo.isDirectory()) {
+                if (!config) {
+                    config = configArrayFactory.getConfigArrayForFile(
+                        filePath,
+                        { ignoreNotFoundError: true }
+                    );
+                }
+                const ignored = this._isIgnoredFile(
+                    filePath + path.sep,
+                    { ...options, config }
+                );
 
-		if (ignoreFlag) {
-			const config =
-				providedConfig ||
-				configArrayFactory.getConfigArrayForFile(filePath, {
-					ignoreNotFoundError: true,
-				});
-			const ignores =
-				config.extractConfig(filePath).ignores || defaultIgnores;
+                if (!ignored) {
+                    yield* this._iterateFilesRecursive(filePath, options);
+                }
+            }
+        }
 
-			return ignores(filePath, dotfiles);
-		}
+        debug(`Leave the directory: ${directoryPath}`);
+    }
 
-		return !direct && defaultIgnores(filePath, dotfiles);
-	}
+    /**
+     * Check if a given file should be ignored.
+     * @param {string} filePath The path to a file to check.
+     * @param {Object} options Options
+     * @param {ConfigArray} [options.config] The config for this file.
+     * @param {boolean} [options.dotfiles] If `true` then this is not ignore dot files by default.
+     * @param {boolean} [options.direct] If `true` then this is a direct specified file.
+     * @returns {boolean} `true` if the file should be ignored.
+     * @private
+     */
+    _isIgnoredFile(filePath, {
+        config: providedConfig,
+        dotfiles = false,
+        direct = false
+    }) {
+        const {
+            configArrayFactory,
+            defaultIgnores,
+            ignoreFlag
+        } = internalSlotsMap.get(this);
+
+        if (ignoreFlag) {
+            const config =
+                providedConfig ||
+                configArrayFactory.getConfigArrayForFile(
+                    filePath,
+                    { ignoreNotFoundError: true }
+                );
+            const ignores =
+                config.extractConfig(filePath).ignores || defaultIgnores;
+
+            return ignores(filePath, dotfiles);
+        }
+
+        return !direct && defaultIgnores(filePath, dotfiles);
+    }
 }
 
 //------------------------------------------------------------------------------

frontend/node_modules/eslint/lib/cli-engine/formatters/checkstyle.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview CheckStyle XML reporter
+ * @author Ian Christian Myers
+ */
+"use strict";
+
+const xmlEscape = require("../xml-escape");
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns the severity of warning or error
+ * @param {Object} message message object to examine
+ * @returns {string} severity level
+ * @private
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "error";
+    }
+    return "warning";
+
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "";
+
+    output += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+    output += "<checkstyle version=\"4.3\">";
+
+    results.forEach(result => {
+        const messages = result.messages;
+
+        output += `<file name="${xmlEscape(result.filePath)}">`;
+
+        messages.forEach(message => {
+            output += [
+                `<error line="${xmlEscape(message.line || 0)}"`,
+                `column="${xmlEscape(message.column || 0)}"`,
+                `severity="${xmlEscape(getMessageType(message))}"`,
+                `message="${xmlEscape(message.message)}${message.ruleId ? ` (${message.ruleId})` : ""}"`,
+                `source="${message.ruleId ? xmlEscape(`eslint.rules.${message.ruleId}`) : ""}" />`
+            ].join(" ");
+        });
+
+        output += "</file>";
+
+    });
+
+    output += "</checkstyle>";
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/compact.js

@@ -0,0 +1,60 @@
+/**
+ * @fileoverview Compact reporter
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns the severity of warning or error
+ * @param {Object} message message object to examine
+ * @returns {string} severity level
+ * @private
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "Error";
+    }
+    return "Warning";
+
+}
+
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "",
+        total = 0;
+
+    results.forEach(result => {
+
+        const messages = result.messages;
+
+        total += messages.length;
+
+        messages.forEach(message => {
+
+            output += `${result.filePath}: `;
+            output += `line ${message.line || 0}`;
+            output += `, col ${message.column || 0}`;
+            output += `, ${getMessageType(message)}`;
+            output += ` - ${message.message}`;
+            output += message.ruleId ? ` (${message.ruleId})` : "";
+            output += "\n";
+
+        });
+
+    });
+
+    if (total > 0) {
+        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
+    }
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/formatters-meta.json

@@ -1,18 +1,46 @@
 [
-  {
-    "name": "html",
-    "description": "Outputs results to HTML. The `html` formatter is useful for visual presentation in the browser."
-  },
-  {
-    "name": "json-with-metadata",
-    "description": "Outputs JSON-serialized results. The `json-with-metadata` provides the same linting results as the [`json`](#json) formatter with additional metadata about the rules applied. The linting results are included in the `results` property and the rules metadata is included in the `metadata` property.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint."
-  },
-  {
-    "name": "json",
-    "description": "Outputs JSON-serialized results. The `json` formatter is useful when you want to programmatically work with the CLI's linting results.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint."
-  },
-  {
-    "name": "stylish",
-    "description": "Human-readable output format. This is the default formatter."
-  }
-]
+    {
+        "name": "checkstyle",
+        "description": "Outputs results to the [Checkstyle](https://checkstyle.sourceforge.io/) format."
+    },
+    {
+        "name": "compact",
+        "description": "Human-readable output format. Mimics the default output of JSHint."
+    },
+    {
+        "name": "html",
+        "description": "Outputs results to HTML. The `html` formatter is useful for visual presentation in the browser."
+    },
+    {
+        "name": "jslint-xml",
+        "description": "Outputs results to format compatible with the [JSLint Jenkins plugin](https://plugins.jenkins.io/jslint/)."
+    },
+    {
+        "name": "json-with-metadata",
+        "description": "Outputs JSON-serialized results. The `json-with-metadata` provides the same linting results as the [`json`](#json) formatter with additional metadata about the rules applied. The linting results are included in the `results` property and the rules metadata is included in the `metadata` property.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint."
+    },
+    {
+        "name": "json",
+        "description": "Outputs JSON-serialized results. The `json` formatter is useful when you want to programmatically work with the CLI's linting results.\n\nAlternatively, you can use the [ESLint Node.js API](../../integrate/nodejs-api) to programmatically use ESLint."
+    },
+    {
+        "name": "junit",
+        "description": "Outputs results to format compatible with the [JUnit Jenkins plugin](https://plugins.jenkins.io/junit/)."
+    },
+    {
+        "name": "stylish",
+        "description": "Human-readable output format. This is the default formatter."
+    },
+    {
+        "name": "tap",
+        "description": "Outputs results to the [Test Anything Protocol (TAP)](https://testanything.org/) specification format."
+    },
+    {
+        "name": "unix",
+        "description": "Outputs results to a format similar to many commands in UNIX-like systems. Parsable with tools such as [grep](https://www.gnu.org/software/grep/manual/grep.html), [sed](https://www.gnu.org/software/sed/manual/sed.html), and [awk](https://www.gnu.org/software/gawk/manual/gawk.html)."
+    },
+    {
+        "name": "visualstudio",
+        "description": "Outputs results to format compatible with the integrated terminal of the [Visual Studio](https://visualstudio.microsoft.com/) IDE. When using Visual Studio, you can click on the linting results in the integrated terminal to go to the issue in the source code."
+    }
+]

frontend/node_modules/eslint/lib/cli-engine/formatters/html.js

@@ -8,22 +8,22 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const encodeHTML = (function () {
-	const encodeHTMLRules = {
-		"&": "&",
-		"<": "&#60;",
-		">": "&#62;",
-		'"': "&#34;",
-		"'": "&#39;",
-	};
-	const matchHTML = /[&<>"']/gu;
+const encodeHTML = (function() {
+    const encodeHTMLRules = {
+        "&": "&#38;",
+        "<": "&#60;",
+        ">": "&#62;",
+        '"': "&#34;",
+        "'": "&#39;"
+    };
+    const matchHTML = /[&<>"']/ug;
 
-	return function (code) {
-		return code
-			? code.toString().replace(matchHTML, m => encodeHTMLRules[m] || m)
-			: "";
-	};
-})();
+    return function(code) {
+        return code
+            ? code.toString().replace(matchHTML, m => encodeHTMLRules[m] || m)
+            : "";
+    };
+}());
 
 /**
  * Get the final HTML document.
@@ -31,9 +31,9 @@ const encodeHTML = (function () {
  * @returns {string} HTML document.
  */
 function pageTemplate(it) {
-	const { reportColor, reportSummary, date, results } = it;
+    const { reportColor, reportSummary, date, results } = it;
 
-	return `
+    return `
 <!DOCTYPE html>
 <html>
     <head>
@@ -182,11 +182,11 @@ function pageTemplate(it) {
 /**
  * Given a word and a count, append an s if count is not one.
  * @param {string} word A word in its singular form.
- * @param {number} count A number controlling whether word should be pluralized.
+ * @param {int} count A number controlling whether word should be pluralized.
  * @returns {string} The original word with an s on the end if count is not one.
  */
 function pluralize(word, count) {
-	return count === 1 ? word : `${word}s`;
+    return (count === 1 ? word : `${word}s`);
 }
 
 /**
@@ -196,29 +196,29 @@ function pluralize(word, count) {
  * @returns {string} The formatted string, pluralized where necessary
  */
 function renderSummary(totalErrors, totalWarnings) {
-	const totalProblems = totalErrors + totalWarnings;
-	let renderedText = `${totalProblems} ${pluralize("problem", totalProblems)}`;
+    const totalProblems = totalErrors + totalWarnings;
+    let renderedText = `${totalProblems} ${pluralize("problem", totalProblems)}`;
 
-	if (totalProblems !== 0) {
-		renderedText += ` (${totalErrors} ${pluralize("error", totalErrors)}, ${totalWarnings} ${pluralize("warning", totalWarnings)})`;
-	}
-	return renderedText;
+    if (totalProblems !== 0) {
+        renderedText += ` (${totalErrors} ${pluralize("error", totalErrors)}, ${totalWarnings} ${pluralize("warning", totalWarnings)})`;
+    }
+    return renderedText;
 }
 
 /**
  * Get the color based on whether there are errors/warnings...
  * @param {string} totalErrors Total errors
  * @param {string} totalWarnings Total warnings
- * @returns {number} The color code (0 = green, 1 = yellow, 2 = red)
+ * @returns {int} The color code (0 = green, 1 = yellow, 2 = red)
  */
 function renderColor(totalErrors, totalWarnings) {
-	if (totalErrors !== 0) {
-		return 2;
-	}
-	if (totalWarnings !== 0) {
-		return 1;
-	}
-	return 0;
+    if (totalErrors !== 0) {
+        return 2;
+    }
+    if (totalWarnings !== 0) {
+        return 1;
+    }
+    return 0;
 }
 
 /**
@@ -227,18 +227,18 @@ function renderColor(totalErrors, totalWarnings) {
  * @returns {string} HTML (table row) describing the message.
  */
 function messageTemplate(it) {
-	const {
-		parentIndex,
-		lineNumber,
-		columnNumber,
-		severityNumber,
-		severityName,
-		message,
-		ruleUrl,
-		ruleId,
-	} = it;
+    const {
+        parentIndex,
+        lineNumber,
+        columnNumber,
+        severityNumber,
+        severityName,
+        message,
+        ruleUrl,
+        ruleId
+    } = it;
 
-	return `
+    return `
 <tr style="display: none;" class="f-${parentIndex}">
     <td>${lineNumber}:${columnNumber}</td>
     <td class="clr-${severityNumber}">${severityName}</td>
@@ -253,42 +253,41 @@ function messageTemplate(it) {
 /**
  * Get HTML (table rows) describing the messages.
  * @param {Array} messages Messages.
- * @param {number} parentIndex Index of the parent HTML row.
+ * @param {int} parentIndex Index of the parent HTML row.
  * @param {Object} rulesMeta Dictionary containing metadata for each rule executed by the analysis.
  * @returns {string} HTML (table rows) describing the messages.
  */
 function renderMessages(messages, parentIndex, rulesMeta) {
-	/**
-	 * Get HTML (table row) describing a message.
-	 * @param {Object} message Message.
-	 * @returns {string} HTML (table row) describing a message.
-	 */
-	return messages
-		.map(message => {
-			const lineNumber = message.line || 0;
-			const columnNumber = message.column || 0;
-			let ruleUrl;
 
-			if (rulesMeta) {
-				const meta = rulesMeta[message.ruleId];
+    /**
+     * Get HTML (table row) describing a message.
+     * @param {Object} message Message.
+     * @returns {string} HTML (table row) describing a message.
+     */
+    return messages.map(message => {
+        const lineNumber = message.line || 0;
+        const columnNumber = message.column || 0;
+        let ruleUrl;
 
-				if (meta && meta.docs && meta.docs.url) {
-					ruleUrl = meta.docs.url;
-				}
-			}
+        if (rulesMeta) {
+            const meta = rulesMeta[message.ruleId];
 
-			return messageTemplate({
-				parentIndex,
-				lineNumber,
-				columnNumber,
-				severityNumber: message.severity,
-				severityName: message.severity === 1 ? "Warning" : "Error",
-				message: message.message,
-				ruleId: message.ruleId,
-				ruleUrl,
-			});
-		})
-		.join("\n");
+            if (meta && meta.docs && meta.docs.url) {
+                ruleUrl = meta.docs.url;
+            }
+        }
+
+        return messageTemplate({
+            parentIndex,
+            lineNumber,
+            columnNumber,
+            severityNumber: message.severity,
+            severityName: message.severity === 1 ? "Warning" : "Error",
+            message: message.message,
+            ruleId: message.ruleId,
+            ruleUrl
+        });
+    }).join("\n");
 }
 
 /**
@@ -297,9 +296,9 @@ function renderMessages(messages, parentIndex, rulesMeta) {
  * @returns {string} HTML (table row) describing the result for the file.
  */
 function resultTemplate(it) {
-	const { color, index, filePath, summary } = it;
+    const { color, index, filePath, summary } = it;
 
-	return `
+    return `
 <tr class="bg-${color}" data-group="f-${index}">
     <th colspan="4">
         [+] ${encodeHTML(filePath)}
@@ -316,44 +315,37 @@ function resultTemplate(it) {
  * @returns {string} HTML string describing the results.
  */
 function renderResults(results, rulesMeta) {
-	return results
-		.map(
-			(result, index) =>
-				resultTemplate({
-					index,
-					color: renderColor(result.errorCount, result.warningCount),
-					filePath: result.filePath,
-					summary: renderSummary(
-						result.errorCount,
-						result.warningCount,
-					),
-				}) + renderMessages(result.messages, index, rulesMeta),
-		)
-		.join("\n");
+    return results.map((result, index) => resultTemplate({
+        index,
+        color: renderColor(result.errorCount, result.warningCount),
+        filePath: result.filePath,
+        summary: renderSummary(result.errorCount, result.warningCount)
+    }) + renderMessages(result.messages, index, rulesMeta)).join("\n");
 }
 
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = function (results, data) {
-	let totalErrors, totalWarnings;
+module.exports = function(results, data) {
+    let totalErrors,
+        totalWarnings;
 
-	const metaData = data ? data.rulesMeta : {};
+    const metaData = data ? data.rulesMeta : {};
 
-	totalErrors = 0;
-	totalWarnings = 0;
+    totalErrors = 0;
+    totalWarnings = 0;
 
-	// Iterate over results to get totals
-	results.forEach(result => {
-		totalErrors += result.errorCount;
-		totalWarnings += result.warningCount;
-	});
+    // Iterate over results to get totals
+    results.forEach(result => {
+        totalErrors += result.errorCount;
+        totalWarnings += result.warningCount;
+    });
 
-	return pageTemplate({
-		date: new Date(),
-		reportColor: renderColor(totalErrors, totalWarnings),
-		reportSummary: renderSummary(totalErrors, totalWarnings),
-		results: renderResults(results, metaData),
-	});
+    return pageTemplate({
+        date: new Date(),
+        reportColor: renderColor(totalErrors, totalWarnings),
+        reportSummary: renderSummary(totalErrors, totalWarnings),
+        results: renderResults(results, metaData)
+    });
 };

frontend/node_modules/eslint/lib/cli-engine/formatters/jslint-xml.js

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview JSLint XML reporter
+ * @author Ian Christian Myers
+ */
+"use strict";
+
+const xmlEscape = require("../xml-escape");
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "";
+
+    output += "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
+    output += "<jslint>";
+
+    results.forEach(result => {
+        const messages = result.messages;
+
+        output += `<file name="${result.filePath}">`;
+
+        messages.forEach(message => {
+            output += [
+                `<issue line="${message.line}"`,
+                `char="${message.column}"`,
+                `evidence="${xmlEscape(message.source || "")}"`,
+                `reason="${xmlEscape(message.message || "")}${message.ruleId ? ` (${message.ruleId})` : ""}" />`
+            ].join(" ");
+        });
+
+        output += "</file>";
+
+    });
+
+    output += "</jslint>";
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/json-with-metadata.js

@@ -8,9 +8,9 @@
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = function (results, data) {
-	return JSON.stringify({
-		results,
-		metadata: data,
-	});
+module.exports = function(results, data) {
+    return JSON.stringify({
+        results,
+        metadata: data
+    });
 };

frontend/node_modules/eslint/lib/cli-engine/formatters/json.js

@@ -8,6 +8,6 @@
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = function (results) {
-	return JSON.stringify(results);
+module.exports = function(results) {
+    return JSON.stringify(results);
 };

frontend/node_modules/eslint/lib/cli-engine/formatters/junit.js

@@ -0,0 +1,82 @@
+/**
+ * @fileoverview jUnit Reporter
+ * @author Jamund Ferguson
+ */
+"use strict";
+
+const xmlEscape = require("../xml-escape");
+const path = require("path");
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns the severity of warning or error
+ * @param {Object} message message object to examine
+ * @returns {string} severity level
+ * @private
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "Error";
+    }
+    return "Warning";
+
+}
+
+/**
+ * Returns a full file path without extension
+ * @param {string} filePath input file path
+ * @returns {string} file path without extension
+ * @private
+ */
+function pathWithoutExt(filePath) {
+    return path.join(path.dirname(filePath), path.basename(filePath, path.extname(filePath)));
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "";
+
+    output += "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n";
+    output += "<testsuites>\n";
+
+    results.forEach(result => {
+
+        const messages = result.messages;
+        const classname = pathWithoutExt(result.filePath);
+
+        if (messages.length > 0) {
+            output += `<testsuite package="org.eslint" time="0" tests="${messages.length}" errors="${messages.length}" name="${result.filePath}">\n`;
+            messages.forEach(message => {
+                const type = message.fatal ? "error" : "failure";
+
+                output += `<testcase time="0" name="org.eslint.${message.ruleId || "unknown"}" classname="${classname}">`;
+                output += `<${type} message="${xmlEscape(message.message || "")}">`;
+                output += "<![CDATA[";
+                output += `line ${message.line || 0}, col `;
+                output += `${message.column || 0}, ${getMessageType(message)}`;
+                output += ` - ${xmlEscape(message.message || "")}`;
+                output += (message.ruleId ? ` (${message.ruleId})` : "");
+                output += "]]>";
+                output += `</${type}>`;
+                output += "</testcase>\n";
+            });
+            output += "</testsuite>\n";
+        } else {
+            output += `<testsuite package="org.eslint" time="0" tests="1" errors="0" name="${result.filePath}">\n`;
+            output += `<testcase time="0" name="${result.filePath}" classname="${classname}" />\n`;
+            output += "</testsuite>\n";
+        }
+
+    });
+
+    output += "</testsuites>\n";
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/stylish.js

@@ -5,8 +5,8 @@
 "use strict";
 
 const chalk = require("chalk"),
-	util = require("node:util"),
-	table = require("../../shared/text-table");
+    stripAnsi = require("strip-ansi"),
+    table = require("text-table");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -15,108 +15,87 @@ const chalk = require("chalk"),
 /**
  * Given a word and a count, append an s if count is not one.
  * @param {string} word A word in its singular form.
- * @param {number} count A number controlling whether word should be pluralized.
+ * @param {int} count A number controlling whether word should be pluralized.
  * @returns {string} The original word with an s on the end if count is not one.
  */
 function pluralize(word, count) {
-	return count === 1 ? word : `${word}s`;
+    return (count === 1 ? word : `${word}s`);
 }
 
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
 
-module.exports = function (results) {
-	let output = "\n",
-		errorCount = 0,
-		warningCount = 0,
-		fixableErrorCount = 0,
-		fixableWarningCount = 0,
-		summaryColor = "yellow";
+module.exports = function(results) {
 
-	results.forEach(result => {
-		const messages = result.messages;
+    let output = "\n",
+        errorCount = 0,
+        warningCount = 0,
+        fixableErrorCount = 0,
+        fixableWarningCount = 0,
+        summaryColor = "yellow";
 
-		if (messages.length === 0) {
-			return;
-		}
+    results.forEach(result => {
+        const messages = result.messages;
 
-		errorCount += result.errorCount;
-		warningCount += result.warningCount;
-		fixableErrorCount += result.fixableErrorCount;
-		fixableWarningCount += result.fixableWarningCount;
+        if (messages.length === 0) {
+            return;
+        }
 
-		output += `${chalk.underline(result.filePath)}\n`;
+        errorCount += result.errorCount;
+        warningCount += result.warningCount;
+        fixableErrorCount += result.fixableErrorCount;
+        fixableWarningCount += result.fixableWarningCount;
 
-		output += `${table(
-			messages.map(message => {
-				let messageType;
+        output += `${chalk.underline(result.filePath)}\n`;
 
-				if (message.fatal || message.severity === 2) {
-					messageType = chalk.red("error");
-					summaryColor = "red";
-				} else {
-					messageType = chalk.yellow("warning");
-				}
+        output += `${table(
+            messages.map(message => {
+                let messageType;
 
-				return [
-					"",
-					String(message.line || 0),
-					String(message.column || 0),
-					messageType,
-					message.message.replace(/([^ ])\.$/u, "$1"),
-					chalk.dim(message.ruleId || ""),
-				];
-			}),
-			{
-				align: ["", "r", "l"],
-				stringLength(str) {
-					return util.stripVTControlCharacters(str).length;
-				},
-			},
-		)
-			.split("\n")
-			.map(el =>
-				el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) =>
-					chalk.dim(`${p1}:${p2}`),
-				),
-			)
-			.join("\n")}\n\n`;
-	});
+                if (message.fatal || message.severity === 2) {
+                    messageType = chalk.red("error");
+                    summaryColor = "red";
+                } else {
+                    messageType = chalk.yellow("warning");
+                }
 
-	const total = errorCount + warningCount;
+                return [
+                    "",
+                    message.line || 0,
+                    message.column || 0,
+                    messageType,
+                    message.message.replace(/([^ ])\.$/u, "$1"),
+                    chalk.dim(message.ruleId || "")
+                ];
+            }),
+            {
+                align: ["", "r", "l"],
+                stringLength(str) {
+                    return stripAnsi(str).length;
+                }
+            }
+        ).split("\n").map(el => el.replace(/(\d+)\s+(\d+)/u, (m, p1, p2) => chalk.dim(`${p1}:${p2}`))).join("\n")}\n\n`;
+    });
 
-	if (total > 0) {
-		output += chalk[summaryColor].bold(
-			[
-				"\u2716 ",
-				total,
-				pluralize(" problem", total),
-				" (",
-				errorCount,
-				pluralize(" error", errorCount),
-				", ",
-				warningCount,
-				pluralize(" warning", warningCount),
-				")\n",
-			].join(""),
-		);
+    const total = errorCount + warningCount;
 
-		if (fixableErrorCount > 0 || fixableWarningCount > 0) {
-			output += chalk[summaryColor].bold(
-				[
-					"  ",
-					fixableErrorCount,
-					pluralize(" error", fixableErrorCount),
-					" and ",
-					fixableWarningCount,
-					pluralize(" warning", fixableWarningCount),
-					" potentially fixable with the `--fix` option.\n",
-				].join(""),
-			);
-		}
-	}
+    if (total > 0) {
+        output += chalk[summaryColor].bold([
+            "\u2716 ", total, pluralize(" problem", total),
+            " (", errorCount, pluralize(" error", errorCount), ", ",
+            warningCount, pluralize(" warning", warningCount), ")\n"
+        ].join(""));
 
-	// Resets output color, for prevent change on top level
-	return total > 0 ? chalk.reset(output) : "";
+        if (fixableErrorCount > 0 || fixableWarningCount > 0) {
+            output += chalk[summaryColor].bold([
+                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), " and ",
+                fixableWarningCount, pluralize(" warning", fixableWarningCount),
+                " potentially fixable with the `--fix` option.\n"
+            ].join(""));
+        }
+    }
+
+    // Resets output color, for prevent change on top level
+    return total > 0 ? chalk.reset(output) : "";
 };

frontend/node_modules/eslint/lib/cli-engine/formatters/tap.js

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview TAP reporter
+ * @author Jonathan Kingston
+ */
+"use strict";
+
+const yaml = require("js-yaml");
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns a canonical error level string based upon the error message passed in.
+ * @param {Object} message Individual error message provided by eslint
+ * @returns {string} Error level string
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "error";
+    }
+    return "warning";
+}
+
+/**
+ * Takes in a JavaScript object and outputs a TAP diagnostics string
+ * @param {Object} diagnostic JavaScript object to be embedded as YAML into output.
+ * @returns {string} diagnostics string with YAML embedded - TAP version 13 compliant
+ */
+function outputDiagnostics(diagnostic) {
+    const prefix = "  ";
+    let output = `${prefix}---\n`;
+
+    output += prefix + yaml.dump(diagnostic).split("\n").join(`\n${prefix}`);
+    output += "...\n";
+    return output;
+}
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+    let output = `TAP version 13\n1..${results.length}\n`;
+
+    results.forEach((result, id) => {
+        const messages = result.messages;
+        let testResult = "ok";
+        let diagnostics = {};
+
+        if (messages.length > 0) {
+            messages.forEach(message => {
+                const severity = getMessageType(message);
+                const diagnostic = {
+                    message: message.message,
+                    severity,
+                    data: {
+                        line: message.line || 0,
+                        column: message.column || 0,
+                        ruleId: message.ruleId || ""
+                    }
+                };
+
+                // This ensures a warning message is not flagged as error
+                if (severity === "error") {
+                    testResult = "not ok";
+                }
+
+                /*
+                 * If we have multiple messages place them under a messages key
+                 * The first error will be logged as message key
+                 * This is to adhere to TAP 13 loosely defined specification of having a message key
+                 */
+                if ("message" in diagnostics) {
+                    if (typeof diagnostics.messages === "undefined") {
+                        diagnostics.messages = [];
+                    }
+                    diagnostics.messages.push(diagnostic);
+                } else {
+                    diagnostics = diagnostic;
+                }
+            });
+        }
+
+        output += `${testResult} ${id + 1} - ${result.filePath}\n`;
+
+        // If we have an error include diagnostics
+        if (messages.length > 0) {
+            output += outputDiagnostics(diagnostics);
+        }
+
+    });
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/unix.js

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview unix-style formatter.
+ * @author oshi-shinobu
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns a canonical error level string based upon the error message passed in.
+ * @param {Object} message Individual error message provided by eslint
+ * @returns {string} Error level string
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "Error";
+    }
+    return "Warning";
+
+}
+
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "",
+        total = 0;
+
+    results.forEach(result => {
+
+        const messages = result.messages;
+
+        total += messages.length;
+
+        messages.forEach(message => {
+
+            output += `${result.filePath}:`;
+            output += `${message.line || 0}:`;
+            output += `${message.column || 0}:`;
+            output += ` ${message.message} `;
+            output += `[${getMessageType(message)}${message.ruleId ? `/${message.ruleId}` : ""}]`;
+            output += "\n";
+
+        });
+
+    });
+
+    if (total > 0) {
+        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
+    }
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/formatters/visualstudio.js

@@ -0,0 +1,63 @@
+/**
+ * @fileoverview Visual Studio compatible formatter
+ * @author Ronald Pijnacker
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helper Functions
+//------------------------------------------------------------------------------
+
+/**
+ * Returns the severity of warning or error
+ * @param {Object} message message object to examine
+ * @returns {string} severity level
+ * @private
+ */
+function getMessageType(message) {
+    if (message.fatal || message.severity === 2) {
+        return "error";
+    }
+    return "warning";
+
+}
+
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+module.exports = function(results) {
+
+    let output = "",
+        total = 0;
+
+    results.forEach(result => {
+
+        const messages = result.messages;
+
+        total += messages.length;
+
+        messages.forEach(message => {
+
+            output += result.filePath;
+            output += `(${message.line || 0}`;
+            output += message.column ? `,${message.column}` : "";
+            output += `): ${getMessageType(message)}`;
+            output += message.ruleId ? ` ${message.ruleId}` : "";
+            output += ` : ${message.message}`;
+            output += "\n";
+
+        });
+
+    });
+
+    if (total === 0) {
+        output += "no problems";
+    } else {
+        output += `\n${total} problem${total !== 1 ? "s" : ""}`;
+    }
+
+    return output;
+};

frontend/node_modules/eslint/lib/cli-engine/hash.js

@@ -25,7 +25,7 @@ const murmur = require("imurmurhash");
  * @returns {string} the hash
  */
 function hash(str) {
-	return murmur(str).result().toString(36);
+    return murmur(str).result().toString(36);
 }
 
 //------------------------------------------------------------------------------

frontend/node_modules/eslint/lib/cli-engine/index.js

@@ -3,5 +3,5 @@
 const { CLIEngine } = require("./cli-engine");
 
 module.exports = {
-	CLIEngine,
+    CLIEngine
 };

frontend/node_modules/eslint/lib/cli-engine/lint-result-cache.js

@@ -8,21 +8,15 @@
 // Requirements
 //-----------------------------------------------------------------------------
 
-const fs = require("node:fs");
+const assert = require("assert");
+const fs = require("fs");
 const fileEntryCache = require("file-entry-cache");
 const stringify = require("json-stable-stringify-without-jsonify");
 const pkg = require("../../package.json");
-const assert = require("../shared/assert");
 const hash = require("./hash");
 
 const debug = require("debug")("eslint:lint-result-cache");
 
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/** @typedef {import("../types").Linter.Config} Config */
-
 //-----------------------------------------------------------------------------
 // Helpers
 //-----------------------------------------------------------------------------
@@ -32,8 +26,8 @@ const nodeVersion = process && process.version;
 
 const validCacheStrategies = ["metadata", "content"];
 const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${validCacheStrategies
-	.map(strategy => `"${strategy}"`)
-	.join(", ")}`;
+    .map(strategy => `"${strategy}"`)
+    .join(", ")}`;
 
 /**
  * Tests whether a provided cacheStrategy is valid
@@ -41,23 +35,22 @@ const invalidCacheStrategyErrorMessage = `Cache strategy must be one of: ${valid
  * @returns {boolean} true if `cacheStrategy` is one of `validCacheStrategies`; false otherwise
  */
 function isValidCacheStrategy(cacheStrategy) {
-	return validCacheStrategies.includes(cacheStrategy);
+    return (
+        validCacheStrategies.includes(cacheStrategy)
+    );
 }
 
 /**
  * Calculates the hash of the config
- * @param {Config} config The config.
+ * @param {ConfigArray} config The config.
  * @returns {string} The hash of the config
  */
 function hashOfConfigFor(config) {
-	if (!configHashCache.has(config)) {
-		configHashCache.set(
-			config,
-			hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`),
-		);
-	}
+    if (!configHashCache.has(config)) {
+        configHashCache.set(config, hash(`${pkg.version}_${nodeVersion}_${stringify(config)}`));
+    }
 
-	return configHashCache.get(config);
+    return configHashCache.get(config);
 }
 
 //-----------------------------------------------------------------------------
@@ -70,151 +63,141 @@ function hashOfConfigFor(config) {
  * serialize and adding them back in on retrieval.
  */
 class LintResultCache {
-	/**
-	 * Creates a new LintResultCache instance.
-	 * @param {string} cacheFileLocation The cache file location.
-	 * @param {"metadata" | "content"} cacheStrategy The cache strategy to use.
-	 */
-	constructor(cacheFileLocation, cacheStrategy) {
-		assert(cacheFileLocation, "Cache file location is required");
-		assert(cacheStrategy, "Cache strategy is required");
-		assert(
-			isValidCacheStrategy(cacheStrategy),
-			invalidCacheStrategyErrorMessage,
-		);
 
-		debug(`Caching results to ${cacheFileLocation}`);
+    /**
+     * Creates a new LintResultCache instance.
+     * @param {string} cacheFileLocation The cache file location.
+     * @param {"metadata" | "content"} cacheStrategy The cache strategy to use.
+     */
+    constructor(cacheFileLocation, cacheStrategy) {
+        assert(cacheFileLocation, "Cache file location is required");
+        assert(cacheStrategy, "Cache strategy is required");
+        assert(
+            isValidCacheStrategy(cacheStrategy),
+            invalidCacheStrategyErrorMessage
+        );
 
-		const useChecksum = cacheStrategy === "content";
+        debug(`Caching results to ${cacheFileLocation}`);
 
-		debug(`Using "${cacheStrategy}" strategy to detect changes`);
+        const useChecksum = cacheStrategy === "content";
 
-		this.fileEntryCache = fileEntryCache.create(
-			cacheFileLocation,
-			void 0,
-			useChecksum,
-		);
-		this.cacheFileLocation = cacheFileLocation;
-	}
+        debug(
+            `Using "${cacheStrategy}" strategy to detect changes`
+        );
 
-	/**
-	 * Retrieve cached lint results for a given file path, if present in the
-	 * cache. If the file is present and has not been changed, rebuild any
-	 * missing result information.
-	 * @param {string} filePath The file for which to retrieve lint results.
-	 * @param {Config} config The config of the file.
-	 * @returns {Object|null} The rebuilt lint results, or null if the file is
-	 *   changed or not in the filesystem.
-	 */
-	getCachedLintResults(filePath, config) {
-		const cachedResults = this.getValidCachedLintResults(filePath, config);
+        this.fileEntryCache = fileEntryCache.create(
+            cacheFileLocation,
+            void 0,
+            useChecksum
+        );
+        this.cacheFileLocation = cacheFileLocation;
+    }
 
-		if (!cachedResults) {
-			return cachedResults;
-		}
+    /**
+     * Retrieve cached lint results for a given file path, if present in the
+     * cache. If the file is present and has not been changed, rebuild any
+     * missing result information.
+     * @param {string} filePath The file for which to retrieve lint results.
+     * @param {ConfigArray} config The config of the file.
+     * @returns {Object|null} The rebuilt lint results, or null if the file is
+     *   changed or not in the filesystem.
+     */
+    getCachedLintResults(filePath, config) {
 
-		/*
-		 * Shallow clone the object to ensure that any properties added or modified afterwards
-		 * will not be accidentally stored in the cache file when `reconcile()` is called.
-		 * https://github.com/eslint/eslint/issues/13507
-		 * All intentional changes to the cache file must be done through `setCachedLintResults()`.
-		 */
-		const results = { ...cachedResults };
+        /*
+         * Cached lint results are valid if and only if:
+         * 1. The file is present in the filesystem
+         * 2. The file has not changed since the time it was previously linted
+         * 3. The ESLint configuration has not changed since the time the file
+         *    was previously linted
+         * If any of these are not true, we will not reuse the lint results.
+         */
+        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
+        const hashOfConfig = hashOfConfigFor(config);
+        const changed =
+            fileDescriptor.changed ||
+            fileDescriptor.meta.hashOfConfig !== hashOfConfig;
 
-		// If source is present but null, need to reread the file from the filesystem.
-		if (results.source === null) {
-			debug(
-				`Rereading cached result source from filesystem: ${filePath}`,
-			);
-			results.source = fs.readFileSync(filePath, "utf-8");
-		}
+        if (fileDescriptor.notFound) {
+            debug(`File not found on the file system: ${filePath}`);
+            return null;
+        }
 
-		return results;
-	}
+        if (changed) {
+            debug(`Cache entry not found or no longer valid: ${filePath}`);
+            return null;
+        }
 
-	/**
-	 * Retrieve cached lint results for a given file path, if present in the
-	 * cache and still valid.
-	 * @param {string} filePath The file for which to retrieve lint results.
-	 * @param {Config} config The config of the file.
-	 * @returns {Object|null} The cached lint results if present in the cache
-	 * and still valid; null otherwise.
-	 */
-	getValidCachedLintResults(filePath, config) {
-		/*
-		 * Cached lint results are valid if and only if:
-		 * 1. The file is present in the filesystem
-		 * 2. The file has not changed since the time it was previously linted
-		 * 3. The ESLint configuration has not changed since the time the file
-		 *    was previously linted
-		 * If any of these are not true, we will not reuse the lint results.
-		 */
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
+        const cachedResults = fileDescriptor.meta.results;
 
-		if (fileDescriptor.notFound) {
-			debug(`File not found on the file system: ${filePath}`);
-			return null;
-		}
+        // Just in case, not sure if this can ever happen.
+        if (!cachedResults) {
+            return cachedResults;
+        }
 
-		const hashOfConfig = hashOfConfigFor(config);
-		const changed =
-			fileDescriptor.changed ||
-			fileDescriptor.meta.hashOfConfig !== hashOfConfig;
+        /*
+         * Shallow clone the object to ensure that any properties added or modified afterwards
+         * will not be accidentally stored in the cache file when `reconcile()` is called.
+         * https://github.com/eslint/eslint/issues/13507
+         * All intentional changes to the cache file must be done through `setCachedLintResults()`.
+         */
+        const results = { ...cachedResults };
 
-		if (changed) {
-			debug(`Cache entry not found or no longer valid: ${filePath}`);
-			return null;
-		}
+        // If source is present but null, need to reread the file from the filesystem.
+        if (results.source === null) {
+            debug(`Rereading cached result source from filesystem: ${filePath}`);
+            results.source = fs.readFileSync(filePath, "utf-8");
+        }
 
-		return fileDescriptor.meta.results;
-	}
+        return results;
+    }
 
-	/**
-	 * Set the cached lint results for a given file path, after removing any
-	 * information that will be both unnecessary and difficult to serialize.
-	 * Avoids caching results with an "output" property (meaning fixes were
-	 * applied), to prevent potentially incorrect results if fixes are not
-	 * written to disk.
-	 * @param {string} filePath The file for which to set lint results.
-	 * @param {Config} config The config of the file.
-	 * @param {Object} result The lint result to be set for the file.
-	 * @returns {void}
-	 */
-	setCachedLintResults(filePath, config, result) {
-		if (result && Object.hasOwn(result, "output")) {
-			return;
-		}
+    /**
+     * Set the cached lint results for a given file path, after removing any
+     * information that will be both unnecessary and difficult to serialize.
+     * Avoids caching results with an "output" property (meaning fixes were
+     * applied), to prevent potentially incorrect results if fixes are not
+     * written to disk.
+     * @param {string} filePath The file for which to set lint results.
+     * @param {ConfigArray} config The config of the file.
+     * @param {Object} result The lint result to be set for the file.
+     * @returns {void}
+     */
+    setCachedLintResults(filePath, config, result) {
+        if (result && Object.prototype.hasOwnProperty.call(result, "output")) {
+            return;
+        }
 
-		const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
+        const fileDescriptor = this.fileEntryCache.getFileDescriptor(filePath);
 
-		if (fileDescriptor && !fileDescriptor.notFound) {
-			debug(`Updating cached result: ${filePath}`);
+        if (fileDescriptor && !fileDescriptor.notFound) {
+            debug(`Updating cached result: ${filePath}`);
 
-			// Serialize the result, except that we want to remove the file source if present.
-			const resultToSerialize = Object.assign({}, result);
+            // Serialize the result, except that we want to remove the file source if present.
+            const resultToSerialize = Object.assign({}, result);
 
-			/*
-			 * Set result.source to null.
-			 * In `getCachedLintResults`, if source is explicitly null, we will
-			 * read the file from the filesystem to set the value again.
-			 */
-			if (Object.hasOwn(resultToSerialize, "source")) {
-				resultToSerialize.source = null;
-			}
+            /*
+             * Set result.source to null.
+             * In `getCachedLintResults`, if source is explicitly null, we will
+             * read the file from the filesystem to set the value again.
+             */
+            if (Object.prototype.hasOwnProperty.call(resultToSerialize, "source")) {
+                resultToSerialize.source = null;
+            }
 
-			fileDescriptor.meta.results = resultToSerialize;
-			fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);
-		}
-	}
+            fileDescriptor.meta.results = resultToSerialize;
+            fileDescriptor.meta.hashOfConfig = hashOfConfigFor(config);
+        }
+    }
 
-	/**
-	 * Persists the in-memory cache to disk.
-	 * @returns {void}
-	 */
-	reconcile() {
-		debug(`Persisting cached results: ${this.cacheFileLocation}`);
-		this.fileEntryCache.reconcile();
-	}
+    /**
+     * Persists the in-memory cache to disk.
+     * @returns {void}
+     */
+    reconcile() {
+        debug(`Persisting cached results: ${this.cacheFileLocation}`);
+        this.fileEntryCache.reconcile();
+    }
 }
 
 module.exports = LintResultCache;

frontend/node_modules/eslint/lib/cli-engine/load-rules.js

@@ -9,8 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const fs = require("node:fs"),
-	path = require("node:path");
+const fs = require("fs"),
+    path = require("path");
 
 const rulesDirCache = {};
 
@@ -24,23 +24,23 @@ const rulesDirCache = {};
  * @param {string} cwd Current working directory
  * @returns {Object} Loaded rule modules.
  */
-module.exports = function (relativeRulesDir, cwd) {
-	const rulesDir = path.resolve(cwd, relativeRulesDir);
+module.exports = function(relativeRulesDir, cwd) {
+    const rulesDir = path.resolve(cwd, relativeRulesDir);
 
-	// cache will help performance as IO operation are expensive
-	if (rulesDirCache[rulesDir]) {
-		return rulesDirCache[rulesDir];
-	}
+    // cache will help performance as IO operation are expensive
+    if (rulesDirCache[rulesDir]) {
+        return rulesDirCache[rulesDir];
+    }
 
-	const rules = Object.create(null);
+    const rules = Object.create(null);
 
-	fs.readdirSync(rulesDir).forEach(file => {
-		if (path.extname(file) !== ".js") {
-			return;
-		}
-		rules[file.slice(0, -3)] = require(path.join(rulesDir, file));
-	});
-	rulesDirCache[rulesDir] = rules;
+    fs.readdirSync(rulesDir).forEach(file => {
+        if (path.extname(file) !== ".js") {
+            return;
+        }
+        rules[file.slice(0, -3)] = require(path.join(rulesDir, file));
+    });
+    rulesDirCache[rulesDir] = rules;
 
-	return rules;
+    return rules;
 };

frontend/node_modules/eslint/lib/cli-engine/xml-escape.js

@@ -0,0 +1,34 @@
+/**
+ * @fileoverview XML character escaper
+ * @author George Chung
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Public Interface
+//------------------------------------------------------------------------------
+
+/**
+ * Returns the escaped value for a character
+ * @param {string} s string to examine
+ * @returns {string} severity level
+ * @private
+ */
+module.exports = function(s) {
+    return (`${s}`).replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, c => { // eslint-disable-line no-control-regex -- Converting controls to entities
+        switch (c) {
+            case "<":
+                return "&lt;";
+            case ">":
+                return "&gt;";
+            case "&":
+                return "&amp;";
+            case "\"":
+                return "&quot;";
+            case "'":
+                return "&apos;";
+            default:
+                return `&#${c.charCodeAt(0)};`;
+        }
+    });
+};