It appears you have a well-structured Git repository with various files, including SVG icons and HTML documents. Here's a brief overview:

backend/node_modules/tinyglobby/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Madeline Gurriarán
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

backend/node_modules/tinyglobby/README.md

@@ -0,0 +1,72 @@
+# tinyglobby
+
+[![npm version](https://img.shields.io/npm/v/tinyglobby.svg?maxAge=3600)](https://npmjs.com/package/tinyglobby)
+[![monthly downloads](https://img.shields.io/npm/dm/tinyglobby.svg?maxAge=3600)](https://npmjs.com/package/tinyglobby)
+
+A fast and minimal alternative to globby and fast-glob, meant to behave the same way.
+
+Both globby and fast-glob present some behavior no other globbing lib has,
+which makes it hard to manually replace with something smaller and better.
+
+This library uses only two subdependencies, compared to `globby`'s [23](https://npmgraph.js.org/?q=globby@14.1.0)
+and `fast-glob`'s [17](https://npmgraph.js.org/?q=fast-glob@3.3.3).
+
+## Usage
+
+```js
+import { glob, globSync } from 'tinyglobby';
+
+await glob(['files/*.ts', '!**/*.d.ts'], { cwd: 'src' });
+globSync(['src/**/*.ts'], { ignore: ['**/*.d.ts'] });
+```
+
+## API
+
+- `glob(patterns: string | string[], options: GlobOptions): Promise<string[]>`: Returns a promise with an array of matches.
+- `globSync(patterns: string | string[], options: GlobOptions): string[]`: Returns an array of matches.
+- `convertPathToPattern(path: string): string`: Converts a path to a pattern depending on the platform.
+- `escapePath(path: string): string`: Escapes a path's special characters depending on the platform.
+- `isDynamicPattern(pattern: string, options?: GlobOptions): boolean`: Checks if a pattern is dynamic.
+
+## Options
+
+- `patterns`: An array of glob patterns to search for. Defaults to `['**/*']`.
+- `ignore`: An array of glob patterns to ignore.
+- `cwd`: The current working directory in which to search. Defaults to `process.cwd()`.
+- `absolute`: Whether to return absolute paths. Defaults to `false`.
+- `dot`: Whether to allow entries starting with a dot. Defaults to `false`.
+- `deep`: Maximum depth of a directory. Defaults to `Infinity`.
+- `followSymbolicLinks`: Whether to traverse and include symbolic links. Defaults to `true`.
+- `caseSensitiveMatch`: Whether to match in case-sensitive mode. Defaults to `true`.
+- `expandDirectories`: Whether to expand directories. Disable to best match `fast-glob`. Defaults to `true`.
+- `onlyDirectories`: Enable to only return directories. Disables `onlyFiles` if set. Defaults to `false`.
+- `onlyFiles`: Enable to only return files. Defaults to `true`.
+- `debug`: Enable debug logs. Useful for development purposes.
+
+## Used by
+
+`tinyglobby` is downloaded many times by projects all around the world. Here's a partial list of notable projects that use it:
+
+<!-- should be sorted by weekly download count -->
+- [`vite`](https://github.com/vitejs/vite)
+- [`pnpm`](https://github.com/pnpm/pnpm)
+- [`node-gyp`](https://github.com/nodejs/node-gyp)
+- [`eslint-import-resolver-typescript`](https://github.com/import-js/eslint-import-resolver-typescript)
+- [`vitest`](https://github.com/vitest-dev/vitest)
+- [`copy-webpack-plugin`](https://github.com/webpack-contrib/copy-webpack-plugin)
+- [`storybook`](https://github.com/storybookjs/storybook)
+- [`ts-morph`](https://github.com/dsherret/ts-morph)
+- [`nx`](https://github.com/nrwl/nx)
+- [`sort-package-json`](https://github.com/keithamus/sort-package-json)
+- [`unimport`](https://github.com/unjs/unimport)
+- [`tsup`](https://github.com/egoist/tsup)
+- [`lerna`](https://github.com/lerna/lerna)
+- [`cspell`](https://github.com/streetsidesoftware/cspell)
+- [`nuxt`](https://github.com/nuxt/nuxt)
+- [`postcss-mixins`](https://github.com/postcss/postcss-mixins)
+- [`astro`](https://github.com/withastro/astro)
+- [`unocss`](https://github.com/unocss/unocss)
+- [`vitepress`](https://github.com/vuejs/vitepress)
+- [`pkg-pr-new`](https://github.com/stackblitz-labs/pkg.pr.new)
+- Your own project? [Open an issue](https://github.com/SuperchupuDev/tinyglobby/issues)
+if you feel like this list is incomplete.

backend/node_modules/tinyglobby/dist/index.d.mts

@@ -0,0 +1,46 @@
+//#region src/utils.d.ts
+
+declare const convertPathToPattern: (path: string) => string;
+declare const escapePath: (path: string) => string;
+// #endregion
+// #region isDynamicPattern
+/*
+Has a few minor differences with `fast-glob` for better accuracy:
+
+Doesn't necessarily return false on patterns that include `\\`.
+
+Returns true if the pattern includes parentheses,
+regardless of them representing one single pattern or not.
+
+Returns true for unfinished glob extensions i.e. `(h`, `+(h`.
+
+Returns true for unfinished brace expansions as long as they include `,` or `..`.
+*/
+declare function isDynamicPattern(pattern: string, options?: {
+  caseSensitiveMatch: boolean;
+}): boolean; //#endregion
+//#region src/index.d.ts
+
+// #endregion
+// #region log
+interface GlobOptions {
+  absolute?: boolean;
+  cwd?: string;
+  patterns?: string | string[];
+  ignore?: string | string[];
+  dot?: boolean;
+  deep?: number;
+  followSymbolicLinks?: boolean;
+  caseSensitiveMatch?: boolean;
+  expandDirectories?: boolean;
+  onlyDirectories?: boolean;
+  onlyFiles?: boolean;
+  debug?: boolean;
+}
+declare function glob(patterns: string | string[], options?: Omit<GlobOptions, "patterns">): Promise<string[]>;
+declare function glob(options: GlobOptions): Promise<string[]>;
+declare function globSync(patterns: string | string[], options?: Omit<GlobOptions, "patterns">): string[];
+declare function globSync(options: GlobOptions): string[];
+
+//#endregion
+export { GlobOptions, convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };

backend/node_modules/tinyglobby/dist/index.d.ts

@@ -0,0 +1,46 @@
+//#region src/utils.d.ts
+
+declare const convertPathToPattern: (path: string) => string;
+declare const escapePath: (path: string) => string;
+// #endregion
+// #region isDynamicPattern
+/*
+Has a few minor differences with `fast-glob` for better accuracy:
+
+Doesn't necessarily return false on patterns that include `\\`.
+
+Returns true if the pattern includes parentheses,
+regardless of them representing one single pattern or not.
+
+Returns true for unfinished glob extensions i.e. `(h`, `+(h`.
+
+Returns true for unfinished brace expansions as long as they include `,` or `..`.
+*/
+declare function isDynamicPattern(pattern: string, options?: {
+  caseSensitiveMatch: boolean;
+}): boolean; //#endregion
+//#region src/index.d.ts
+
+// #endregion
+// #region log
+interface GlobOptions {
+  absolute?: boolean;
+  cwd?: string;
+  patterns?: string | string[];
+  ignore?: string | string[];
+  dot?: boolean;
+  deep?: number;
+  followSymbolicLinks?: boolean;
+  caseSensitiveMatch?: boolean;
+  expandDirectories?: boolean;
+  onlyDirectories?: boolean;
+  onlyFiles?: boolean;
+  debug?: boolean;
+}
+declare function glob(patterns: string | string[], options?: Omit<GlobOptions, "patterns">): Promise<string[]>;
+declare function glob(options: GlobOptions): Promise<string[]>;
+declare function globSync(patterns: string | string[], options?: Omit<GlobOptions, "patterns">): string[];
+declare function globSync(options: GlobOptions): string[];
+
+//#endregion
+export { GlobOptions, convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };

backend/node_modules/tinyglobby/dist/index.js

@@ -0,0 +1,267 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const path = __toESM(require("path"));
+const fdir = __toESM(require("fdir"));
+const picomatch = __toESM(require("picomatch"));
+
+//#region src/utils.ts
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const regexes = Array(patternsCount);
+	for (let i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partRegexes = Array(partsCount);
+		for (let j = 0; j < partsCount; j++) partRegexes[j] = picomatch.default.makeRe(parts[j], options);
+		regexes[i] = partRegexes;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (let i = 0; i < patterns.length; i++) {
+			const patternParts = patternsParts[i];
+			const regex = regexes[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			let j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				const match = regex[j].test(inputParts[j]);
+				if (!match) break;
+				if (part === "**") return true;
+				j++;
+			}
+			if (j === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path$2) {
+	var _result$parts;
+	const result = picomatch.default.scan(path$2, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$2];
+}
+const isWin = process.platform === "win32";
+const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path$2) {
+	return escapePosixPath(path$2);
+}
+function convertWin32PathToPattern(path$2) {
+	return escapeWin32Path(path$2).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$2) => path$2.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$2) => path$2.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
+	const scan = picomatch.default.scan(pattern);
+	return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+
+//#endregion
+//#region src/index.ts
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+	let result = pattern;
+	if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+	if (!result.endsWith("*") && expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	if (path.default.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) result = path.posix.relative(escapedCwd, result);
+	else result = path.posix.normalize(result);
+	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+	const parts = splitPattern(result);
+	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
+		const n = (parentDirectoryMatch[0].length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = path.posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
+		if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? path.default.posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+	if (typeof patterns === "string") patterns = [patterns];
+	else if (!patterns) patterns = ["**/*"];
+	if (typeof ignore === "string") ignore = [ignore];
+	const matchPatterns = [];
+	const ignorePatterns = [];
+	for (const pattern of ignore) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+	}
+	for (const pattern of patterns) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
+		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+	}
+	return {
+		match: matchPatterns,
+		ignore: ignorePatterns
+	};
+}
+function getRelativePath(path$2, cwd, root) {
+	return path.posix.relative(cwd, `${root}/${path$2}`) || ".";
+}
+function processPath(path$2, cwd, root, isDirectory, absolute) {
+	const relativePath = absolute ? path$2.slice(root === "/" ? 1 : root.length + 1) || "." : path$2;
+	if (root === cwd) return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
+	return getRelativePath(relativePath, cwd, root);
+}
+function formatPaths(paths, cwd, root) {
+	for (let i = paths.length - 1; i >= 0; i--) {
+		const path$2 = paths[i];
+		paths[i] = getRelativePath(path$2, cwd, root) + (!path$2 || path$2.endsWith("/") ? "/" : "");
+	}
+	return paths;
+}
+function crawl(options, cwd, sync) {
+	if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
+	if (options.debug) log("globbing with options:", options, "cwd:", cwd);
+	if (Array.isArray(options.patterns) && options.patterns.length === 0) return sync ? [] : Promise.resolve([]);
+	const props = {
+		root: cwd,
+		commonPath: null,
+		depthOffset: 0
+	};
+	const processed = processPatterns(options, cwd, props);
+	const nocase = options.caseSensitiveMatch === false;
+	if (options.debug) log("internal processing patterns:", processed);
+	const matcher = (0, picomatch.default)(processed.match, {
+		dot: options.dot,
+		nocase,
+		ignore: processed.ignore
+	});
+	const ignore = (0, picomatch.default)(processed.ignore, {
+		dot: options.dot,
+		nocase
+	});
+	const partialMatcher = getPartialMatcher(processed.match, {
+		dot: options.dot,
+		nocase
+	});
+	const fdirOptions = {
+		filters: [options.debug ? (p, isDirectory) => {
+			const path$2 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+			const matches = matcher(path$2);
+			if (matches) log(`matched ${path$2}`);
+			return matches;
+		} : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
+		exclude: options.debug ? (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+			if (skipped) log(`skipped ${p}`);
+			else log(`crawling ${p}`);
+			return skipped;
+		} : (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+		},
+		pathSeparator: "/",
+		relativePaths: true,
+		resolveSymlinks: true
+	};
+	if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+	if (options.absolute) {
+		fdirOptions.relativePaths = false;
+		fdirOptions.resolvePaths = true;
+		fdirOptions.includeBasePath = true;
+	}
+	if (options.followSymbolicLinks === false) {
+		fdirOptions.resolveSymlinks = false;
+		fdirOptions.excludeSymlinks = true;
+	}
+	if (options.onlyDirectories) {
+		fdirOptions.excludeFiles = true;
+		fdirOptions.includeDirs = true;
+	} else if (options.onlyFiles === false) fdirOptions.includeDirs = true;
+	props.root = props.root.replace(BACKSLASHES, "");
+	const root = props.root;
+	if (options.debug) log("internal properties:", props);
+	const api = new fdir.fdir(fdirOptions).crawl(root);
+	if (cwd === root || options.absolute) return sync ? api.sync() : api.withPromise();
+	return sync ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
+}
+async function glob(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+		...options,
+		patterns: patternsOrOptions
+	} : patternsOrOptions;
+	const cwd = opts.cwd ? path.default.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+	return crawl(opts, cwd, false);
+}
+function globSync(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+		...options,
+		patterns: patternsOrOptions
+	} : patternsOrOptions;
+	const cwd = opts.cwd ? path.default.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+	return crawl(opts, cwd, true);
+}
+
+//#endregion
+exports.convertPathToPattern = convertPathToPattern;
+exports.escapePath = escapePath;
+exports.glob = glob;
+exports.globSync = globSync;
+exports.isDynamicPattern = isDynamicPattern;

backend/node_modules/tinyglobby/dist/index.mjs

@@ -0,0 +1,240 @@
+import path, { posix } from "path";
+import { fdir } from "fdir";
+import picomatch from "picomatch";
+
+//#region src/utils.ts
+const ONLY_PARENT_DIRECTORIES = /^(\/?\.\.)+$/;
+function getPartialMatcher(patterns, options) {
+	const patternsCount = patterns.length;
+	const patternsParts = Array(patternsCount);
+	const regexes = Array(patternsCount);
+	for (let i = 0; i < patternsCount; i++) {
+		const parts = splitPattern(patterns[i]);
+		patternsParts[i] = parts;
+		const partsCount = parts.length;
+		const partRegexes = Array(partsCount);
+		for (let j = 0; j < partsCount; j++) partRegexes[j] = picomatch.makeRe(parts[j], options);
+		regexes[i] = partRegexes;
+	}
+	return (input) => {
+		const inputParts = input.split("/");
+		if (inputParts[0] === ".." && ONLY_PARENT_DIRECTORIES.test(input)) return true;
+		for (let i = 0; i < patterns.length; i++) {
+			const patternParts = patternsParts[i];
+			const regex = regexes[i];
+			const inputPatternCount = inputParts.length;
+			const minParts = Math.min(inputPatternCount, patternParts.length);
+			let j = 0;
+			while (j < minParts) {
+				const part = patternParts[j];
+				if (part.includes("/")) return true;
+				const match = regex[j].test(inputParts[j]);
+				if (!match) break;
+				if (part === "**") return true;
+				j++;
+			}
+			if (j === inputPatternCount) return true;
+		}
+		return false;
+	};
+}
+const splitPatternOptions = { parts: true };
+function splitPattern(path$1) {
+	var _result$parts;
+	const result = picomatch.scan(path$1, splitPatternOptions);
+	return ((_result$parts = result.parts) === null || _result$parts === void 0 ? void 0 : _result$parts.length) ? result.parts : [path$1];
+}
+const isWin = process.platform === "win32";
+const ESCAPED_WIN32_BACKSLASHES = /\\(?![()[\]{}!+@])/g;
+function convertPosixPathToPattern(path$1) {
+	return escapePosixPath(path$1);
+}
+function convertWin32PathToPattern(path$1) {
+	return escapeWin32Path(path$1).replace(ESCAPED_WIN32_BACKSLASHES, "/");
+}
+const convertPathToPattern = isWin ? convertWin32PathToPattern : convertPosixPathToPattern;
+const POSIX_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}*?|]|^!|[!+@](?=\()|\\(?![()[\]{}!*+?@|]))/g;
+const WIN32_UNESCAPED_GLOB_SYMBOLS = /(?<!\\)([()[\]{}]|^!|[!+@](?=\())/g;
+const escapePosixPath = (path$1) => path$1.replace(POSIX_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapeWin32Path = (path$1) => path$1.replace(WIN32_UNESCAPED_GLOB_SYMBOLS, "\\$&");
+const escapePath = isWin ? escapeWin32Path : escapePosixPath;
+function isDynamicPattern(pattern, options) {
+	if ((options === null || options === void 0 ? void 0 : options.caseSensitiveMatch) === false) return true;
+	const scan = picomatch.scan(pattern);
+	return scan.isGlob || scan.negated;
+}
+function log(...tasks) {
+	console.log(`[tinyglobby ${new Date().toLocaleTimeString("es")}]`, ...tasks);
+}
+
+//#endregion
+//#region src/index.ts
+const PARENT_DIRECTORY = /^(\/?\.\.)+/;
+const ESCAPING_BACKSLASHES = /\\(?=[()[\]{}!*+?@|])/g;
+const BACKSLASHES = /\\/g;
+function normalizePattern(pattern, expandDirectories, cwd, props, isIgnore) {
+	let result = pattern;
+	if (pattern.endsWith("/")) result = pattern.slice(0, -1);
+	if (!result.endsWith("*") && expandDirectories) result += "/**";
+	const escapedCwd = escapePath(cwd);
+	if (path.isAbsolute(result.replace(ESCAPING_BACKSLASHES, ""))) result = posix.relative(escapedCwd, result);
+	else result = posix.normalize(result);
+	const parentDirectoryMatch = PARENT_DIRECTORY.exec(result);
+	const parts = splitPattern(result);
+	if (parentDirectoryMatch === null || parentDirectoryMatch === void 0 ? void 0 : parentDirectoryMatch[0]) {
+		const n = (parentDirectoryMatch[0].length + 1) / 3;
+		let i = 0;
+		const cwdParts = escapedCwd.split("/");
+		while (i < n && parts[i + n] === cwdParts[cwdParts.length + i - n]) {
+			result = result.slice(0, (n - i - 1) * 3) + result.slice((n - i) * 3 + parts[i + n].length + 1) || ".";
+			i++;
+		}
+		const potentialRoot = posix.join(cwd, parentDirectoryMatch[0].slice(i * 3));
+		if (!potentialRoot.startsWith(".") && props.root.length > potentialRoot.length) {
+			props.root = potentialRoot;
+			props.depthOffset = -n + i;
+		}
+	}
+	if (!isIgnore && props.depthOffset >= 0) {
+		var _props$commonPath;
+		(_props$commonPath = props.commonPath) !== null && _props$commonPath !== void 0 || (props.commonPath = parts);
+		const newCommonPath = [];
+		const length = Math.min(props.commonPath.length, parts.length);
+		for (let i = 0; i < length; i++) {
+			const part = parts[i];
+			if (part === "**" && !parts[i + 1]) {
+				newCommonPath.pop();
+				break;
+			}
+			if (part !== props.commonPath[i] || isDynamicPattern(part) || i === parts.length - 1) break;
+			newCommonPath.push(part);
+		}
+		props.depthOffset = newCommonPath.length;
+		props.commonPath = newCommonPath;
+		props.root = newCommonPath.length > 0 ? path.posix.join(cwd, ...newCommonPath) : cwd;
+	}
+	return result;
+}
+function processPatterns({ patterns, ignore = [], expandDirectories = true }, cwd, props) {
+	if (typeof patterns === "string") patterns = [patterns];
+	else if (!patterns) patterns = ["**/*"];
+	if (typeof ignore === "string") ignore = [ignore];
+	const matchPatterns = [];
+	const ignorePatterns = [];
+	for (const pattern of ignore) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") ignorePatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, true));
+	}
+	for (const pattern of patterns) {
+		if (!pattern) continue;
+		if (pattern[0] !== "!" || pattern[1] === "(") matchPatterns.push(normalizePattern(pattern, expandDirectories, cwd, props, false));
+		else if (pattern[1] !== "!" || pattern[2] === "(") ignorePatterns.push(normalizePattern(pattern.slice(1), expandDirectories, cwd, props, true));
+	}
+	return {
+		match: matchPatterns,
+		ignore: ignorePatterns
+	};
+}
+function getRelativePath(path$1, cwd, root) {
+	return posix.relative(cwd, `${root}/${path$1}`) || ".";
+}
+function processPath(path$1, cwd, root, isDirectory, absolute) {
+	const relativePath = absolute ? path$1.slice(root === "/" ? 1 : root.length + 1) || "." : path$1;
+	if (root === cwd) return isDirectory && relativePath !== "." ? relativePath.slice(0, -1) : relativePath;
+	return getRelativePath(relativePath, cwd, root);
+}
+function formatPaths(paths, cwd, root) {
+	for (let i = paths.length - 1; i >= 0; i--) {
+		const path$1 = paths[i];
+		paths[i] = getRelativePath(path$1, cwd, root) + (!path$1 || path$1.endsWith("/") ? "/" : "");
+	}
+	return paths;
+}
+function crawl(options, cwd, sync) {
+	if (process.env.TINYGLOBBY_DEBUG) options.debug = true;
+	if (options.debug) log("globbing with options:", options, "cwd:", cwd);
+	if (Array.isArray(options.patterns) && options.patterns.length === 0) return sync ? [] : Promise.resolve([]);
+	const props = {
+		root: cwd,
+		commonPath: null,
+		depthOffset: 0
+	};
+	const processed = processPatterns(options, cwd, props);
+	const nocase = options.caseSensitiveMatch === false;
+	if (options.debug) log("internal processing patterns:", processed);
+	const matcher = picomatch(processed.match, {
+		dot: options.dot,
+		nocase,
+		ignore: processed.ignore
+	});
+	const ignore = picomatch(processed.ignore, {
+		dot: options.dot,
+		nocase
+	});
+	const partialMatcher = getPartialMatcher(processed.match, {
+		dot: options.dot,
+		nocase
+	});
+	const fdirOptions = {
+		filters: [options.debug ? (p, isDirectory) => {
+			const path$1 = processPath(p, cwd, props.root, isDirectory, options.absolute);
+			const matches = matcher(path$1);
+			if (matches) log(`matched ${path$1}`);
+			return matches;
+		} : (p, isDirectory) => matcher(processPath(p, cwd, props.root, isDirectory, options.absolute))],
+		exclude: options.debug ? (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			const skipped = relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+			if (skipped) log(`skipped ${p}`);
+			else log(`crawling ${p}`);
+			return skipped;
+		} : (_, p) => {
+			const relativePath = processPath(p, cwd, props.root, true, true);
+			return relativePath !== "." && !partialMatcher(relativePath) || ignore(relativePath);
+		},
+		pathSeparator: "/",
+		relativePaths: true,
+		resolveSymlinks: true
+	};
+	if (options.deep !== void 0) fdirOptions.maxDepth = Math.round(options.deep - props.depthOffset);
+	if (options.absolute) {
+		fdirOptions.relativePaths = false;
+		fdirOptions.resolvePaths = true;
+		fdirOptions.includeBasePath = true;
+	}
+	if (options.followSymbolicLinks === false) {
+		fdirOptions.resolveSymlinks = false;
+		fdirOptions.excludeSymlinks = true;
+	}
+	if (options.onlyDirectories) {
+		fdirOptions.excludeFiles = true;
+		fdirOptions.includeDirs = true;
+	} else if (options.onlyFiles === false) fdirOptions.includeDirs = true;
+	props.root = props.root.replace(BACKSLASHES, "");
+	const root = props.root;
+	if (options.debug) log("internal properties:", props);
+	const api = new fdir(fdirOptions).crawl(root);
+	if (cwd === root || options.absolute) return sync ? api.sync() : api.withPromise();
+	return sync ? formatPaths(api.sync(), cwd, root) : api.withPromise().then((paths) => formatPaths(paths, cwd, root));
+}
+async function glob(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+		...options,
+		patterns: patternsOrOptions
+	} : patternsOrOptions;
+	const cwd = opts.cwd ? path.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+	return crawl(opts, cwd, false);
+}
+function globSync(patternsOrOptions, options) {
+	if (patternsOrOptions && (options === null || options === void 0 ? void 0 : options.patterns)) throw new Error("Cannot pass patterns as both an argument and an option");
+	const opts = Array.isArray(patternsOrOptions) || typeof patternsOrOptions === "string" ? {
+		...options,
+		patterns: patternsOrOptions
+	} : patternsOrOptions;
+	const cwd = opts.cwd ? path.resolve(opts.cwd).replace(BACKSLASHES, "/") : process.cwd().replace(BACKSLASHES, "/");
+	return crawl(opts, cwd, true);
+}
+
+//#endregion
+export { convertPathToPattern, escapePath, glob, globSync, isDynamicPattern };

backend/node_modules/tinyglobby/node_modules/fdir/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2023 Abdullah Atta
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

backend/node_modules/tinyglobby/node_modules/fdir/README.md

@@ -0,0 +1,91 @@
+<p align="center">
+<img src="https://github.com/thecodrr/fdir/raw/master/assets/fdir.gif" width="75%"/>
+
+<h1 align="center">The Fastest Directory Crawler & Globber for NodeJS</h1>
+<p align="center">
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/npm/v/fdir?style=for-the-badge"/></a>
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/npm/dw/fdir?style=for-the-badge"/></a>
+  <a href="https://codeclimate.com/github/thecodrr/fdir/maintainability"><img src="https://img.shields.io/codeclimate/maintainability-percentage/thecodrr/fdir?style=for-the-badge"/></a>
+  <a href="https://coveralls.io/github/thecodrr/fdir?branch=master"><img src="https://img.shields.io/coveralls/github/thecodrr/fdir?style=for-the-badge"/></a>
+  <a href="https://www.npmjs.com/package/fdir"><img src="https://img.shields.io/bundlephobia/minzip/fdir?style=for-the-badge"/></a>
+  <a href="https://www.producthunt.com/posts/fdir-every-millisecond-matters"><img src="https://img.shields.io/badge/ProductHunt-Upvote-red?style=for-the-badge&logo=product-hunt"/></a>
+  <a href="https://dev.to/thecodrr/how-i-wrote-the-fastest-directory-crawler-ever-3p9c"><img src="https://img.shields.io/badge/dev.to-Read%20Blog-black?style=for-the-badge&logo=dev.to"/></a>
+  <a href="./LICENSE"><img src="https://img.shields.io/github/license/thecodrr/fdir?style=for-the-badge"/></a>
+</p>
+</p>
+
+⚡ **The Fastest:** Nothing similar (in the NodeJS world) beats `fdir` in speed. It can easily crawl a directory containing **1 million files in < 1 second.**
+
+💡 **Stupidly Easy:** `fdir` uses expressive Builder pattern to build the crawler increasing code readability.
+
+🤖 **Zero Dependencies\*:** `fdir` only uses NodeJS `fs` & `path` modules.
+
+🕺 **Astonishingly Small:** < 2KB in size gzipped & minified.
+
+🖮 **Hackable:** Extending `fdir` is extremely simple now that the new Builder API is here. Feel free to experiment around.
+
+_\* `picomatch` must be installed manually by the user to support globbing._
+
+## 🚄 Quickstart
+
+### Installation
+
+You can install using `npm`:
+
+```sh
+$ npm i fdir
+```
+
+or Yarn:
+
+```sh
+$ yarn add fdir
+```
+
+### Usage
+
+```ts
+import { fdir } from "fdir";
+
+// create the builder
+const api = new fdir().withFullPaths().crawl("path/to/dir");
+
+// get all files in a directory synchronously
+const files = api.sync();
+
+// or asynchronously
+api.withPromise().then((files) => {
+  // do something with the result here.
+});
+```
+
+## Documentation:
+
+Documentation for all methods is available [here](/documentation.md).
+
+## 📊 Benchmarks:
+
+Please check the benchmark against the latest version [here](/BENCHMARKS.md).
+
+## 🙏Used by:
+
+`fdir` is downloaded over 200k+ times a week by projects around the world. Here's a list of some notable projects using `fdir` in production:
+
+> Note: if you think your project should be here, feel free to open an issue. Notable is anything with a considerable amount of GitHub stars.
+
+1. [rollup/plugins](https://github.com/rollup/plugins)
+2. [SuperchupuDev/tinyglobby](https://github.com/SuperchupuDev/tinyglobby)
+3. [pulumi/pulumi](https://github.com/pulumi/pulumi)
+4. [dotenvx/dotenvx](https://github.com/dotenvx/dotenvx)
+5. [mdn/yari](https://github.com/mdn/yari)
+6. [streetwriters/notesnook](https://github.com/streetwriters/notesnook)
+7. [imba/imba](https://github.com/imba/imba)
+8. [moroshko/react-scanner](https://github.com/moroshko/react-scanner)
+9. [netlify/build](https://github.com/netlify/build)
+10. [yassinedoghri/astro-i18next](https://github.com/yassinedoghri/astro-i18next)
+11. [selfrefactor/rambda](https://github.com/selfrefactor/rambda)
+12. [whyboris/Video-Hub-App](https://github.com/whyboris/Video-Hub-App)
+
+## 🦮 LICENSE
+
+Copyright &copy; 2024 Abdullah Atta under MIT. [Read full text here.](https://github.com/thecodrr/fdir/raw/master/LICENSE)

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/async.d.ts

@@ -0,0 +1,3 @@
+import { Output, Options, ResultCallback } from "../types";
+export declare function promise<TOutput extends Output>(root: string, options: Options): Promise<TOutput>;
+export declare function callback<TOutput extends Output>(root: string, options: Options, callback: ResultCallback<TOutput>): void;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/async.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.callback = exports.promise = void 0;
+const walker_1 = require("./walker");
+function promise(root, options) {
+    return new Promise((resolve, reject) => {
+        callback(root, options, (err, output) => {
+            if (err)
+                return reject(err);
+            resolve(output);
+        });
+    });
+}
+exports.promise = promise;
+function callback(root, options, callback) {
+    let walker = new walker_1.Walker(root, options, callback);
+    walker.start();
+}
+exports.callback = callback;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/counter.d.ts

@@ -0,0 +1,12 @@
+export declare class Counter {
+    private _files;
+    private _directories;
+    set files(num: number);
+    get files(): number;
+    set directories(num: number);
+    get directories(): number;
+    /**
+     * @deprecated use `directories` instead
+     */
+    get dirs(): number;
+}

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/counter.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Counter = void 0;
+class Counter {
+    _files = 0;
+    _directories = 0;
+    set files(num) {
+        this._files = num;
+    }
+    get files() {
+        return this._files;
+    }
+    set directories(num) {
+        this._directories = num;
+    }
+    get directories() {
+        return this._directories;
+    }
+    /**
+     * @deprecated use `directories` instead
+     */
+    /* c8 ignore next 3 */
+    get dirs() {
+        return this._directories;
+    }
+}
+exports.Counter = Counter;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/get-array.d.ts

@@ -0,0 +1,3 @@
+import { Options } from "../../types";
+export type GetArrayFunction = (paths: string[]) => string[];
+export declare function build(options: Options): GetArrayFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/get-array.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const getArray = (paths) => {
+    return paths;
+};
+const getArrayGroup = () => {
+    return [""].slice(0, 0);
+};
+function build(options) {
+    return options.group ? getArrayGroup : getArray;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/group-files.d.ts

@@ -0,0 +1,3 @@
+import { Group, Options } from "../../types";
+export type GroupFilesFunction = (groups: Group[], directory: string, files: string[]) => void;
+export declare function build(options: Options): GroupFilesFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/group-files.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const groupFiles = (groups, directory, files) => {
+    groups.push({ directory, files, dir: directory });
+};
+const empty = () => { };
+function build(options) {
+    return options.group ? groupFiles : empty;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/invoke-callback.d.ts

@@ -0,0 +1,3 @@
+import { Output, ResultCallback, WalkerState, Options } from "../../types";
+export type InvokeCallbackFunction<TOutput extends Output> = (state: WalkerState, error: Error | null, callback?: ResultCallback<TOutput>) => null | TOutput;
+export declare function build<TOutput extends Output>(options: Options, isSynchronous: boolean): InvokeCallbackFunction<TOutput>;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/invoke-callback.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const onlyCountsSync = (state) => {
+    return state.counts;
+};
+const groupsSync = (state) => {
+    return state.groups;
+};
+const defaultSync = (state) => {
+    return state.paths;
+};
+const limitFilesSync = (state) => {
+    return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback) => {
+    report(error, callback, state.counts, state.options.suppressErrors);
+    return null;
+};
+const defaultAsync = (state, error, callback) => {
+    report(error, callback, state.paths, state.options.suppressErrors);
+    return null;
+};
+const limitFilesAsync = (state, error, callback) => {
+    report(error, callback, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+    return null;
+};
+const groupsAsync = (state, error, callback) => {
+    report(error, callback, state.groups, state.options.suppressErrors);
+    return null;
+};
+function report(error, callback, output, suppressErrors) {
+    if (error && !suppressErrors)
+        callback(error, output);
+    else
+        callback(null, output);
+}
+function build(options, isSynchronous) {
+    const { onlyCounts, group, maxFiles } = options;
+    if (onlyCounts)
+        return isSynchronous
+            ? onlyCountsSync
+            : onlyCountsAsync;
+    else if (group)
+        return isSynchronous
+            ? groupsSync
+            : groupsAsync;
+    else if (maxFiles)
+        return isSynchronous
+            ? limitFilesSync
+            : limitFilesAsync;
+    else
+        return isSynchronous
+            ? defaultSync
+            : defaultAsync;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/join-path.d.ts

@@ -0,0 +1,5 @@
+import { Options, PathSeparator } from "../../types";
+export declare function joinPathWithBasePath(filename: string, directoryPath: string): string;
+export declare function joinDirectoryPath(filename: string, directoryPath: string, separator: PathSeparator): string;
+export type JoinPathFunction = (filename: string, directoryPath: string) => string;
+export declare function build(root: string, options: Options): JoinPathFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/join-path.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = exports.joinDirectoryPath = exports.joinPathWithBasePath = void 0;
+const path_1 = require("path");
+const utils_1 = require("../../utils");
+function joinPathWithBasePath(filename, directoryPath) {
+    return directoryPath + filename;
+}
+exports.joinPathWithBasePath = joinPathWithBasePath;
+function joinPathWithRelativePath(root, options) {
+    return function (filename, directoryPath) {
+        const sameRoot = directoryPath.startsWith(root);
+        if (sameRoot)
+            return directoryPath.replace(root, "") + filename;
+        else
+            return ((0, utils_1.convertSlashes)((0, path_1.relative)(root, directoryPath), options.pathSeparator) +
+                options.pathSeparator +
+                filename);
+    };
+}
+function joinPath(filename) {
+    return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+    return directoryPath + filename + separator;
+}
+exports.joinDirectoryPath = joinDirectoryPath;
+function build(root, options) {
+    const { relativePaths, includeBasePath } = options;
+    return relativePaths && root
+        ? joinPathWithRelativePath(root, options)
+        : includeBasePath
+            ? joinPathWithBasePath
+            : joinPath;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/push-directory.d.ts

@@ -0,0 +1,3 @@
+import { FilterPredicate, Options } from "../../types";
+export type PushDirectoryFunction = (directoryPath: string, paths: string[], filters?: FilterPredicate[]) => void;
+export declare function build(root: string, options: Options): PushDirectoryFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/push-directory.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+function pushDirectoryWithRelativePath(root) {
+    return function (directoryPath, paths) {
+        paths.push(directoryPath.substring(root.length) || ".");
+    };
+}
+function pushDirectoryFilterWithRelativePath(root) {
+    return function (directoryPath, paths, filters) {
+        const relativePath = directoryPath.substring(root.length) || ".";
+        if (filters.every((filter) => filter(relativePath, true))) {
+            paths.push(relativePath);
+        }
+    };
+}
+const pushDirectory = (directoryPath, paths) => {
+    paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+    const path = directoryPath || ".";
+    if (filters.every((filter) => filter(path, true))) {
+        paths.push(path);
+    }
+};
+const empty = () => { };
+function build(root, options) {
+    const { includeDirs, filters, relativePaths } = options;
+    if (!includeDirs)
+        return empty;
+    if (relativePaths)
+        return filters && filters.length
+            ? pushDirectoryFilterWithRelativePath(root)
+            : pushDirectoryWithRelativePath(root);
+    return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/push-file.d.ts

@@ -0,0 +1,3 @@
+import { FilterPredicate, Options, Counts } from "../../types";
+export type PushFileFunction = (directoryPath: string, paths: string[], counts: Counts, filters?: FilterPredicate[]) => void;
+export declare function build(options: Options): PushFileFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/push-file.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+    if (filters.every((filter) => filter(filename, false)))
+        counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+    if (filters.every((filter) => filter(filename, false)))
+        paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+    counts.files++;
+};
+const pushFile = (filename, paths) => {
+    paths.push(filename);
+};
+const empty = () => { };
+function build(options) {
+    const { excludeFiles, filters, onlyCounts } = options;
+    if (excludeFiles)
+        return empty;
+    if (filters && filters.length) {
+        return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+    }
+    else if (onlyCounts) {
+        return pushFileCount;
+    }
+    else {
+        return pushFile;
+    }
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/resolve-symlink.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import fs from "fs";
+import { WalkerState, Options } from "../../types";
+export type ResolveSymlinkFunction = (path: string, state: WalkerState, callback: (stat: fs.Stats, path: string) => void) => void;
+export declare function build(options: Options, isSynchronous: boolean): ResolveSymlinkFunction | null;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/resolve-symlink.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const resolveSymlinksAsync = function (path, state, callback) {
+    const { queue, options: { suppressErrors }, } = state;
+    queue.enqueue();
+    fs_1.default.realpath(path, (error, resolvedPath) => {
+        if (error)
+            return queue.dequeue(suppressErrors ? null : error, state);
+        fs_1.default.stat(resolvedPath, (error, stat) => {
+            if (error)
+                return queue.dequeue(suppressErrors ? null : error, state);
+            if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+                return queue.dequeue(null, state);
+            callback(stat, resolvedPath);
+            queue.dequeue(null, state);
+        });
+    });
+};
+const resolveSymlinks = function (path, state, callback) {
+    const { queue, options: { suppressErrors }, } = state;
+    queue.enqueue();
+    try {
+        const resolvedPath = fs_1.default.realpathSync(path);
+        const stat = fs_1.default.statSync(resolvedPath);
+        if (stat.isDirectory() && isRecursive(path, resolvedPath, state))
+            return;
+        callback(stat, resolvedPath);
+    }
+    catch (e) {
+        if (!suppressErrors)
+            throw e;
+    }
+};
+function build(options, isSynchronous) {
+    if (!options.resolveSymlinks || options.excludeSymlinks)
+        return null;
+    return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+exports.build = build;
+function isRecursive(path, resolved, state) {
+    if (state.options.useRealPaths)
+        return isRecursiveUsingRealPaths(resolved, state);
+    let parent = (0, path_1.dirname)(path);
+    let depth = 1;
+    while (parent !== state.root && depth < 2) {
+        const resolvedPath = state.symlinks.get(parent);
+        const isSameRoot = !!resolvedPath &&
+            (resolvedPath === resolved ||
+                resolvedPath.startsWith(resolved) ||
+                resolved.startsWith(resolvedPath));
+        if (isSameRoot)
+            depth++;
+        else
+            parent = (0, path_1.dirname)(parent);
+    }
+    state.symlinks.set(path, resolved);
+    return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+    return state.visited.includes(resolved + state.options.pathSeparator);
+}

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/walk-directory.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { WalkerState } from "../../types";
+import fs from "fs";
+export type WalkDirectoryFunction = (state: WalkerState, crawlPath: string, directoryPath: string, depth: number, callback: (entries: fs.Dirent[], directoryPath: string, depth: number) => void) => void;
+export declare function build(isSynchronous: boolean): WalkDirectoryFunction;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/functions/walk-directory.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.build = void 0;
+const fs_1 = __importDefault(require("fs"));
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+    state.queue.enqueue();
+    if (currentDepth < 0)
+        return state.queue.dequeue(null, state);
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    // Perf: Node >= 10 introduced withFileTypes that helps us
+    // skip an extra fs.stat call.
+    fs_1.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+        callback(entries, directoryPath, currentDepth);
+        state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+    });
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback) => {
+    if (currentDepth < 0)
+        return;
+    state.visited.push(crawlPath);
+    state.counts.directories++;
+    let entries = [];
+    try {
+        entries = fs_1.default.readdirSync(crawlPath || ".", readdirOpts);
+    }
+    catch (e) {
+        if (!state.options.suppressErrors)
+            throw e;
+    }
+    callback(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+    return isSynchronous ? walkSync : walkAsync;
+}
+exports.build = build;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/queue.d.ts

@@ -0,0 +1,15 @@
+import { WalkerState } from "../types";
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+export declare class Queue {
+    private onQueueEmpty?;
+    count: number;
+    constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+    enqueue(): number;
+    dequeue(error: Error | null, output: WalkerState): void;
+}
+export {};

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/queue.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+class Queue {
+    onQueueEmpty;
+    count = 0;
+    constructor(onQueueEmpty) {
+        this.onQueueEmpty = onQueueEmpty;
+    }
+    enqueue() {
+        this.count++;
+        return this.count;
+    }
+    dequeue(error, output) {
+        if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+            this.onQueueEmpty(error, output);
+            if (error) {
+                output.controller.abort();
+                this.onQueueEmpty = undefined;
+            }
+        }
+    }
+}
+exports.Queue = Queue;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/sync.d.ts

@@ -0,0 +1,2 @@
+import { Output, Options } from "../types";
+export declare function sync<TOutput extends Output>(root: string, options: Options): TOutput;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/sync.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sync = void 0;
+const walker_1 = require("./walker");
+function sync(root, options) {
+    const walker = new walker_1.Walker(root, options);
+    return walker.start();
+}
+exports.sync = sync;

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/walker.d.ts

@@ -0,0 +1,18 @@
+import { ResultCallback, Options } from "../types";
+import { Output } from "../types";
+export declare class Walker<TOutput extends Output> {
+    private readonly root;
+    private readonly isSynchronous;
+    private readonly state;
+    private readonly joinPath;
+    private readonly pushDirectory;
+    private readonly pushFile;
+    private readonly getArray;
+    private readonly groupFiles;
+    private readonly resolveSymlink;
+    private readonly walkDirectory;
+    private readonly callbackInvoker;
+    constructor(root: string, options: Options, callback?: ResultCallback<TOutput>);
+    start(): TOutput | null;
+    private walk;
+}

backend/node_modules/tinyglobby/node_modules/fdir/dist/api/walker.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Walker = void 0;
+const path_1 = require("path");
+const utils_1 = require("../utils");
+const joinPath = __importStar(require("./functions/join-path"));
+const pushDirectory = __importStar(require("./functions/push-directory"));
+const pushFile = __importStar(require("./functions/push-file"));
+const getArray = __importStar(require("./functions/get-array"));
+const groupFiles = __importStar(require("./functions/group-files"));
+const resolveSymlink = __importStar(require("./functions/resolve-symlink"));
+const invokeCallback = __importStar(require("./functions/invoke-callback"));
+const walkDirectory = __importStar(require("./functions/walk-directory"));
+const queue_1 = require("./queue");
+const counter_1 = require("./counter");
+class Walker {
+    root;
+    isSynchronous;
+    state;
+    joinPath;
+    pushDirectory;
+    pushFile;
+    getArray;
+    groupFiles;
+    resolveSymlink;
+    walkDirectory;
+    callbackInvoker;
+    constructor(root, options, callback) {
+        this.isSynchronous = !callback;
+        this.callbackInvoker = invokeCallback.build(options, this.isSynchronous);
+        this.root = (0, utils_1.normalizePath)(root, options);
+        this.state = {
+            root: (0, utils_1.isRootDirectory)(this.root) ? this.root : this.root.slice(0, -1),
+            // Perf: we explicitly tell the compiler to optimize for String arrays
+            paths: [""].slice(0, 0),
+            groups: [],
+            counts: new counter_1.Counter(),
+            options,
+            queue: new queue_1.Queue((error, state) => this.callbackInvoker(state, error, callback)),
+            symlinks: new Map(),
+            visited: [""].slice(0, 0),
+            controller: new AbortController(),
+        };
+        /*
+         * Perf: We conditionally change functions according to options. This gives a slight
+         * performance boost. Since these functions are so small, they are automatically inlined
+         * by the javascript engine so there's no function call overhead (in most cases).
+         */
+        this.joinPath = joinPath.build(this.root, options);
+        this.pushDirectory = pushDirectory.build(this.root, options);
+        this.pushFile = pushFile.build(options);
+        this.getArray = getArray.build(options);
+        this.groupFiles = groupFiles.build(options);
+        this.resolveSymlink = resolveSymlink.build(options, this.isSynchronous);
+        this.walkDirectory = walkDirectory.build(this.isSynchronous);
+    }
+    start() {
+        this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+        this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+        return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+    }
+    walk = (entries, directoryPath, depth) => {
+        const { paths, options: { filters, resolveSymlinks, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator, }, controller, } = this.state;
+        if (controller.signal.aborted ||
+            (signal && signal.aborted) ||
+            (maxFiles && paths.length > maxFiles))
+            return;
+        const files = this.getArray(this.state.paths);
+        for (let i = 0; i < entries.length; ++i) {
+            const entry = entries[i];
+            if (entry.isFile() ||
+                (entry.isSymbolicLink() && !resolveSymlinks && !excludeSymlinks)) {
+                const filename = this.joinPath(entry.name, directoryPath);
+                this.pushFile(filename, files, this.state.counts, filters);
+            }
+            else if (entry.isDirectory()) {
+                let path = joinPath.joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+                if (exclude && exclude(entry.name, path))
+                    continue;
+                this.pushDirectory(path, paths, filters);
+                this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+            }
+            else if (this.resolveSymlink && entry.isSymbolicLink()) {
+                let path = joinPath.joinPathWithBasePath(entry.name, directoryPath);
+                this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
+                    if (stat.isDirectory()) {
+                        resolvedPath = (0, utils_1.normalizePath)(resolvedPath, this.state.options);
+                        if (exclude &&
+                            exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator))
+                            return;
+                        this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+                    }
+                    else {
+                        resolvedPath = useRealPaths ? resolvedPath : path;
+                        const filename = (0, path_1.basename)(resolvedPath);
+                        const directoryPath = (0, utils_1.normalizePath)((0, path_1.dirname)(resolvedPath), this.state.options);
+                        resolvedPath = this.joinPath(filename, directoryPath);
+                        this.pushFile(resolvedPath, files, this.state.counts, filters);
+                    }
+                });
+            }
+        }
+        this.groupFiles(this.state.groups, directoryPath, files);
+    };
+}
+exports.Walker = Walker;

backend/node_modules/tinyglobby/node_modules/fdir/dist/builder/api-builder.d.ts

@@ -0,0 +1,9 @@
+import { Options, Output, ResultCallback } from "../types";
+export declare class APIBuilder<TReturnType extends Output> {
+    private readonly root;
+    private readonly options;
+    constructor(root: string, options: Options);
+    withPromise(): Promise<TReturnType>;
+    withCallback(cb: ResultCallback<TReturnType>): void;
+    sync(): TReturnType;
+}

backend/node_modules/tinyglobby/node_modules/fdir/dist/builder/api-builder.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIBuilder = void 0;
+const async_1 = require("../api/async");
+const sync_1 = require("../api/sync");
+class APIBuilder {
+    root;
+    options;
+    constructor(root, options) {
+        this.root = root;
+        this.options = options;
+    }
+    withPromise() {
+        return (0, async_1.promise)(this.root, this.options);
+    }
+    withCallback(cb) {
+        (0, async_1.callback)(this.root, this.options, cb);
+    }
+    sync() {
+        return (0, sync_1.sync)(this.root, this.options);
+    }
+}
+exports.APIBuilder = APIBuilder;

backend/node_modules/tinyglobby/node_modules/fdir/dist/builder/index.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+import { Output, OnlyCountsOutput, GroupOutput, PathsOutput, Options, FilterPredicate, ExcludePredicate, GlobParams } from "../types";
+import { APIBuilder } from "./api-builder";
+import type picomatch from "picomatch";
+export declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+    private readonly globCache;
+    private options;
+    private globFunction?;
+    constructor(options?: Partial<Options<TGlobFunction>>);
+    group(): Builder<GroupOutput, TGlobFunction>;
+    withPathSeparator(separator: "/" | "\\"): this;
+    withBasePath(): this;
+    withRelativePaths(): this;
+    withDirs(): this;
+    withMaxDepth(depth: number): this;
+    withMaxFiles(limit: number): this;
+    withFullPaths(): this;
+    withErrors(): this;
+    withSymlinks({ resolvePaths }?: {
+        resolvePaths?: boolean | undefined;
+    }): this;
+    withAbortSignal(signal: AbortSignal): this;
+    normalize(): this;
+    filter(predicate: FilterPredicate): this;
+    onlyDirs(): this;
+    exclude(predicate: ExcludePredicate): this;
+    onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+    crawl(root?: string): APIBuilder<TReturnType>;
+    withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+    /**
+     * @deprecated Pass options using the constructor instead:
+     * ```ts
+     * new fdir(options).crawl("/path/to/root");
+     * ```
+     * This method will be removed in v7.0
+     */
+    crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+    glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+    globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+    globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}

backend/node_modules/tinyglobby/node_modules/fdir/dist/builder/index.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Builder = void 0;
+const path_1 = require("path");
+const api_builder_1 = require("./api-builder");
+var pm = null;
+/* c8 ignore next 6 */
+try {
+    require.resolve("picomatch");
+    pm = require("picomatch");
+}
+catch (_e) {
+    // do nothing
+}
+class Builder {
+    globCache = {};
+    options = {
+        maxDepth: Infinity,
+        suppressErrors: true,
+        pathSeparator: path_1.sep,
+        filters: [],
+    };
+    globFunction;
+    constructor(options) {
+        this.options = { ...this.options, ...options };
+        this.globFunction = this.options.globFunction;
+    }
+    group() {
+        this.options.group = true;
+        return this;
+    }
+    withPathSeparator(separator) {
+        this.options.pathSeparator = separator;
+        return this;
+    }
+    withBasePath() {
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withRelativePaths() {
+        this.options.relativePaths = true;
+        return this;
+    }
+    withDirs() {
+        this.options.includeDirs = true;
+        return this;
+    }
+    withMaxDepth(depth) {
+        this.options.maxDepth = depth;
+        return this;
+    }
+    withMaxFiles(limit) {
+        this.options.maxFiles = limit;
+        return this;
+    }
+    withFullPaths() {
+        this.options.resolvePaths = true;
+        this.options.includeBasePath = true;
+        return this;
+    }
+    withErrors() {
+        this.options.suppressErrors = false;
+        return this;
+    }
+    withSymlinks({ resolvePaths = true } = {}) {
+        this.options.resolveSymlinks = true;
+        this.options.useRealPaths = resolvePaths;
+        return this.withFullPaths();
+    }
+    withAbortSignal(signal) {
+        this.options.signal = signal;
+        return this;
+    }
+    normalize() {
+        this.options.normalizePath = true;
+        return this;
+    }
+    filter(predicate) {
+        this.options.filters.push(predicate);
+        return this;
+    }
+    onlyDirs() {
+        this.options.excludeFiles = true;
+        this.options.includeDirs = true;
+        return this;
+    }
+    exclude(predicate) {
+        this.options.exclude = predicate;
+        return this;
+    }
+    onlyCounts() {
+        this.options.onlyCounts = true;
+        return this;
+    }
+    crawl(root) {
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    withGlobFunction(fn) {
+        // cast this since we don't have the new type params yet
+        this.globFunction = fn;
+        return this;
+    }
+    /**
+     * @deprecated Pass options using the constructor instead:
+     * ```ts
+     * new fdir(options).crawl("/path/to/root");
+     * ```
+     * This method will be removed in v7.0
+     */
+    /* c8 ignore next 4 */
+    crawlWithOptions(root, options) {
+        this.options = { ...this.options, ...options };
+        return new api_builder_1.APIBuilder(root || ".", this.options);
+    }
+    glob(...patterns) {
+        if (this.globFunction) {
+            return this.globWithOptions(patterns);
+        }
+        return this.globWithOptions(patterns, ...[{ dot: true }]);
+    }
+    globWithOptions(patterns, ...options) {
+        const globFn = (this.globFunction || pm);
+        /* c8 ignore next 5 */
+        if (!globFn) {
+            throw new Error("Please specify a glob function to use glob matching.");
+        }
+        var isMatch = this.globCache[patterns.join("\0")];
+        if (!isMatch) {
+            isMatch = globFn(patterns, ...options);
+            this.globCache[patterns.join("\0")] = isMatch;
+        }
+        this.options.filters.push((path) => isMatch(path));
+        return this;
+    }
+}
+exports.Builder = Builder;

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.cjs

@@ -0,0 +1,572 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const path = __toESM(require("path"));
+const fs = __toESM(require("fs"));
+
+//#region src/utils.ts
+function cleanPath(path$1) {
+	let normalized = (0, path.normalize)(path$1);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === path.sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path$1, separator) {
+	return path$1.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path$1) {
+	return path$1 === "/" || WINDOWS_ROOT_DIR_REGEX.test(path$1);
+}
+function normalizePath(path$1, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path$1.includes("/") || path$1.startsWith(".");
+	if (resolvePaths) path$1 = (0, path.resolve)(path$1);
+	if (normalizePath$1 || pathNeedsCleaning) path$1 = cleanPath(path$1);
+	if (path$1 === ".") return "";
+	const needsSeperator = path$1[path$1.length - 1] !== pathSeparator;
+	return convertSlashes(needsSeperator ? path$1 + pathSeparator : path$1, pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/join-path.ts
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+	return function(filename, directoryPath) {
+		const sameRoot = directoryPath.startsWith(root);
+		if (sameRoot) return directoryPath.replace(root, "") + filename;
+		else return convertSlashes((0, path.relative)(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+	};
+}
+function joinPath(filename) {
+	return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+	return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+	const { relativePaths, includeBasePath } = options;
+	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+
+//#endregion
+//#region src/api/functions/push-directory.ts
+function pushDirectoryWithRelativePath(root) {
+	return function(directoryPath, paths) {
+		paths.push(directoryPath.substring(root.length) || ".");
+	};
+}
+function pushDirectoryFilterWithRelativePath(root) {
+	return function(directoryPath, paths, filters) {
+		const relativePath = directoryPath.substring(root.length) || ".";
+		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+	};
+}
+const pushDirectory = (directoryPath, paths) => {
+	paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+	const path$1 = directoryPath || ".";
+	if (filters.every((filter) => filter(path$1, true))) paths.push(path$1);
+};
+const empty$2 = () => {};
+function build$6(root, options) {
+	const { includeDirs, filters, relativePaths } = options;
+	if (!includeDirs) return empty$2;
+	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+
+//#endregion
+//#region src/api/functions/push-file.ts
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+	counts.files++;
+};
+const pushFile = (filename, paths) => {
+	paths.push(filename);
+};
+const empty$1 = () => {};
+function build$5(options) {
+	const { excludeFiles, filters, onlyCounts } = options;
+	if (excludeFiles) return empty$1;
+	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+	else if (onlyCounts) return pushFileCount;
+	else return pushFile;
+}
+
+//#endregion
+//#region src/api/functions/get-array.ts
+const getArray = (paths) => {
+	return paths;
+};
+const getArrayGroup = () => {
+	return [""].slice(0, 0);
+};
+function build$4(options) {
+	return options.group ? getArrayGroup : getArray;
+}
+
+//#endregion
+//#region src/api/functions/group-files.ts
+const groupFiles = (groups, directory, files) => {
+	groups.push({
+		directory,
+		files,
+		dir: directory
+	});
+};
+const empty = () => {};
+function build$3(options) {
+	return options.group ? groupFiles : empty;
+}
+
+//#endregion
+//#region src/api/functions/resolve-symlink.ts
+const resolveSymlinksAsync = function(path$1, state, callback$1) {
+	const { queue, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs.default.realpath(path$1, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs.default.stat(resolvedPath, (error$1, stat) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path$1, state, callback$1) {
+	const { queue, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs.default.realpathSync(path$1);
+		const stat = fs.default.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path$1, resolvedPath, state)) return;
+		callback$1(stat, resolvedPath);
+	} catch (e) {
+		if (!suppressErrors) throw e;
+	}
+};
+function build$2(options, isSynchronous) {
+	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path$1, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = (0, path.dirname)(path$1);
+	let depth = 1;
+	while (parent !== state.root && depth < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+		if (isSameRoot) depth++;
+		else parent = (0, path.dirname)(parent);
+	}
+	state.symlinks.set(path$1, resolved);
+	return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+	return state.visited.includes(resolved + state.options.pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/invoke-callback.ts
+const onlyCountsSync = (state) => {
+	return state.counts;
+};
+const groupsSync = (state) => {
+	return state.groups;
+};
+const defaultSync = (state) => {
+	return state.paths;
+};
+const limitFilesSync = (state) => {
+	return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.counts, state.options.suppressErrors);
+	return null;
+};
+const defaultAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths, state.options.suppressErrors);
+	return null;
+};
+const limitFilesAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+	return null;
+};
+const groupsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.groups, state.options.suppressErrors);
+	return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+	if (error && !suppressErrors) callback$1(error, output);
+	else callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+	const { onlyCounts, group, maxFiles } = options;
+	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+	else if (group) return isSynchronous ? groupsSync : groupsAsync;
+	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+	else return isSynchronous ? defaultSync : defaultAsync;
+}
+
+//#endregion
+//#region src/api/functions/walk-directory.ts
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	state.queue.enqueue();
+	if (currentDepth <= 0) return state.queue.dequeue(null, state);
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	fs.default.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+		callback$1(entries, directoryPath, currentDepth);
+		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+	});
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	if (currentDepth <= 0) return;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	let entries = [];
+	try {
+		entries = fs.default.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
+	}
+	callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+
+//#endregion
+//#region src/api/queue.ts
+/**
+* This is a custom stateless queue to track concurrent async fs calls.
+* It increments a counter whenever a call is queued and decrements it
+* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+*/
+var Queue = class {
+	count = 0;
+	constructor(onQueueEmpty) {
+		this.onQueueEmpty = onQueueEmpty;
+	}
+	enqueue() {
+		this.count++;
+		return this.count;
+	}
+	dequeue(error, output) {
+		if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+			this.onQueueEmpty(error, output);
+			if (error) {
+				output.controller.abort();
+				this.onQueueEmpty = void 0;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/api/counter.ts
+var Counter = class {
+	_files = 0;
+	_directories = 0;
+	set files(num) {
+		this._files = num;
+	}
+	get files() {
+		return this._files;
+	}
+	set directories(num) {
+		this._directories = num;
+	}
+	get directories() {
+		return this._directories;
+	}
+	/**
+	* @deprecated use `directories` instead
+	*/
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+
+//#endregion
+//#region src/api/walker.ts
+var Walker = class {
+	root;
+	isSynchronous;
+	state;
+	joinPath;
+	pushDirectory;
+	pushFile;
+	getArray;
+	groupFiles;
+	resolveSymlink;
+	walkDirectory;
+	callbackInvoker;
+	constructor(root, options, callback$1) {
+		this.isSynchronous = !callback$1;
+		this.callbackInvoker = build$1(options, this.isSynchronous);
+		this.root = normalizePath(root, options);
+		this.state = {
+			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+			paths: [""].slice(0, 0),
+			groups: [],
+			counts: new Counter(),
+			options,
+			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+			symlinks: /* @__PURE__ */ new Map(),
+			visited: [""].slice(0, 0),
+			controller: new AbortController()
+		};
+		this.joinPath = build$7(this.root, options);
+		this.pushDirectory = build$6(this.root, options);
+		this.pushFile = build$5(options);
+		this.getArray = build$4(options);
+		this.groupFiles = build$3(options);
+		this.resolveSymlink = build$2(options, this.isSynchronous);
+		this.walkDirectory = build(this.isSynchronous);
+	}
+	start() {
+		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+	}
+	walk = (entries, directoryPath, depth) => {
+		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+		if (controller.signal.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+		const files = this.getArray(this.state.paths);
+		for (let i = 0; i < entries.length; ++i) {
+			const entry = entries[i];
+			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+				const filename = this.joinPath(entry.name, directoryPath);
+				this.pushFile(filename, files, this.state.counts, filters);
+			} else if (entry.isDirectory()) {
+				let path$1 = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path$1)) continue;
+				this.pushDirectory(path$1, paths, filters);
+				this.walkDirectory(this.state, path$1, path$1, depth - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path$1 = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path$1, this.state, (stat, resolvedPath) => {
+					if (stat.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path$1 + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path$1 + pathSeparator, depth - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path$1;
+						const filename = (0, path.basename)(resolvedPath);
+						const directoryPath$1 = normalizePath((0, path.dirname)(resolvedPath), this.state.options);
+						resolvedPath = this.joinPath(filename, directoryPath$1);
+						this.pushFile(resolvedPath, files, this.state.counts, filters);
+					}
+				});
+			}
+		}
+		this.groupFiles(this.state.groups, directoryPath, files);
+	};
+};
+
+//#endregion
+//#region src/api/async.ts
+function promise(root, options) {
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
+		});
+	});
+}
+function callback(root, options, callback$1) {
+	let walker = new Walker(root, options, callback$1);
+	walker.start();
+}
+
+//#endregion
+//#region src/api/sync.ts
+function sync(root, options) {
+	const walker = new Walker(root, options);
+	return walker.start();
+}
+
+//#endregion
+//#region src/builder/api-builder.ts
+var APIBuilder = class {
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+	}
+	withPromise() {
+		return promise(this.root, this.options);
+	}
+	withCallback(cb) {
+		callback(this.root, this.options, cb);
+	}
+	sync() {
+		return sync(this.root, this.options);
+	}
+};
+
+//#endregion
+//#region src/builder/index.ts
+var pm = null;
+/* c8 ignore next 6 */
+try {
+	require.resolve("picomatch");
+	pm = require("picomatch");
+} catch (_e) {}
+var Builder = class {
+	globCache = {};
+	options = {
+		maxDepth: Infinity,
+		suppressErrors: true,
+		pathSeparator: path.sep,
+		filters: []
+	};
+	globFunction;
+	constructor(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.globFunction = this.options.globFunction;
+	}
+	group() {
+		this.options.group = true;
+		return this;
+	}
+	withPathSeparator(separator) {
+		this.options.pathSeparator = separator;
+		return this;
+	}
+	withBasePath() {
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withRelativePaths() {
+		this.options.relativePaths = true;
+		return this;
+	}
+	withDirs() {
+		this.options.includeDirs = true;
+		return this;
+	}
+	withMaxDepth(depth) {
+		this.options.maxDepth = depth;
+		return this;
+	}
+	withMaxFiles(limit) {
+		this.options.maxFiles = limit;
+		return this;
+	}
+	withFullPaths() {
+		this.options.resolvePaths = true;
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withErrors() {
+		this.options.suppressErrors = false;
+		return this;
+	}
+	withSymlinks({ resolvePaths = true } = {}) {
+		this.options.resolveSymlinks = true;
+		this.options.useRealPaths = resolvePaths;
+		return this.withFullPaths();
+	}
+	withAbortSignal(signal) {
+		this.options.signal = signal;
+		return this;
+	}
+	normalize() {
+		this.options.normalizePath = true;
+		return this;
+	}
+	filter(predicate) {
+		this.options.filters.push(predicate);
+		return this;
+	}
+	onlyDirs() {
+		this.options.excludeFiles = true;
+		this.options.includeDirs = true;
+		return this;
+	}
+	exclude(predicate) {
+		this.options.exclude = predicate;
+		return this;
+	}
+	onlyCounts() {
+		this.options.onlyCounts = true;
+		return this;
+	}
+	crawl(root) {
+		return new APIBuilder(root || ".", this.options);
+	}
+	withGlobFunction(fn) {
+		this.globFunction = fn;
+		return this;
+	}
+	/**
+	* @deprecated Pass options using the constructor instead:
+	* ```ts
+	* new fdir(options).crawl("/path/to/root");
+	* ```
+	* This method will be removed in v7.0
+	*/
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new APIBuilder(root || ".", this.options);
+	}
+	glob(...patterns) {
+		if (this.globFunction) return this.globWithOptions(patterns);
+		return this.globWithOptions(patterns, ...[{ dot: true }]);
+	}
+	globWithOptions(patterns, ...options) {
+		const globFn = this.globFunction || pm;
+		/* c8 ignore next 5 */
+		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+		var isMatch = this.globCache[patterns.join("\0")];
+		if (!isMatch) {
+			isMatch = globFn(patterns, ...options);
+			this.globCache[patterns.join("\0")] = isMatch;
+		}
+		this.options.filters.push((path$1) => isMatch(path$1));
+		return this;
+	}
+};
+
+//#endregion
+exports.fdir = Builder;

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.d.cts

@@ -0,0 +1,134 @@
+/// <reference types="node" />
+import picomatch from "picomatch";
+
+//#region src/api/queue.d.ts
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+declare class Queue {
+  private onQueueEmpty?;
+  count: number;
+  constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+  enqueue(): number;
+  dequeue(error: Error | null, output: WalkerState): void;
+}
+//#endregion
+//#region src/types.d.ts
+type Counts = {
+  files: number;
+  directories: number;
+  /**
+   * @deprecated use `directories` instead. Will be removed in v7.0.
+   */
+  dirs: number;
+};
+type Group = {
+  directory: string;
+  files: string[];
+  /**
+   * @deprecated use `directory` instead. Will be removed in v7.0.
+   */
+  dir: string;
+};
+type GroupOutput = Group[];
+type OnlyCountsOutput = Counts;
+type PathsOutput = string[];
+type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+type WalkerState = {
+  root: string;
+  paths: string[];
+  groups: Group[];
+  counts: Counts;
+  options: Options;
+  queue: Queue;
+  controller: AbortController;
+  symlinks: Map<string, string>;
+  visited: string[];
+};
+type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+type PathSeparator = "/" | "\\";
+type Options<TGlobFunction = unknown> = {
+  includeBasePath?: boolean;
+  includeDirs?: boolean;
+  normalizePath?: boolean;
+  maxDepth: number;
+  maxFiles?: number;
+  resolvePaths?: boolean;
+  suppressErrors: boolean;
+  group?: boolean;
+  onlyCounts?: boolean;
+  filters: FilterPredicate[];
+  resolveSymlinks?: boolean;
+  useRealPaths?: boolean;
+  excludeFiles?: boolean;
+  excludeSymlinks?: boolean;
+  exclude?: ExcludePredicate;
+  relativePaths?: boolean;
+  pathSeparator: PathSeparator;
+  signal?: AbortSignal;
+  globFunction?: TGlobFunction;
+};
+type GlobMatcher = (test: string) => boolean;
+type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+type GlobParams<T> = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : [];
+//#endregion
+//#region src/builder/api-builder.d.ts
+declare class APIBuilder<TReturnType extends Output> {
+  private readonly root;
+  private readonly options;
+  constructor(root: string, options: Options);
+  withPromise(): Promise<TReturnType>;
+  withCallback(cb: ResultCallback<TReturnType>): void;
+  sync(): TReturnType;
+}
+//#endregion
+//#region src/builder/index.d.ts
+declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+  private readonly globCache;
+  private options;
+  private globFunction?;
+  constructor(options?: Partial<Options<TGlobFunction>>);
+  group(): Builder<GroupOutput, TGlobFunction>;
+  withPathSeparator(separator: "/" | "\\"): this;
+  withBasePath(): this;
+  withRelativePaths(): this;
+  withDirs(): this;
+  withMaxDepth(depth: number): this;
+  withMaxFiles(limit: number): this;
+  withFullPaths(): this;
+  withErrors(): this;
+  withSymlinks({
+    resolvePaths
+  }?: {
+    resolvePaths?: boolean | undefined;
+  }): this;
+  withAbortSignal(signal: AbortSignal): this;
+  normalize(): this;
+  filter(predicate: FilterPredicate): this;
+  onlyDirs(): this;
+  exclude(predicate: ExcludePredicate): this;
+  onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+  crawl(root?: string): APIBuilder<TReturnType>;
+  withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+  /**
+   * @deprecated Pass options using the constructor instead:
+   * ```ts
+   * new fdir(options).crawl("/path/to/root");
+   * ```
+   * This method will be removed in v7.0
+   */
+  crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+  glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}
+//#endregion
+//#region src/index.d.ts
+type Fdir = typeof Builder;
+//#endregion
+export { Counts, ExcludePredicate, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir };

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.d.mts

@@ -0,0 +1,134 @@
+/// <reference types="node" />
+import picomatch from "picomatch";
+
+//#region src/api/queue.d.ts
+type OnQueueEmptyCallback = (error: Error | null, output: WalkerState) => void;
+/**
+ * This is a custom stateless queue to track concurrent async fs calls.
+ * It increments a counter whenever a call is queued and decrements it
+ * as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+ */
+declare class Queue {
+  private onQueueEmpty?;
+  count: number;
+  constructor(onQueueEmpty?: OnQueueEmptyCallback | undefined);
+  enqueue(): number;
+  dequeue(error: Error | null, output: WalkerState): void;
+}
+//#endregion
+//#region src/types.d.ts
+type Counts = {
+  files: number;
+  directories: number;
+  /**
+   * @deprecated use `directories` instead. Will be removed in v7.0.
+   */
+  dirs: number;
+};
+type Group = {
+  directory: string;
+  files: string[];
+  /**
+   * @deprecated use `directory` instead. Will be removed in v7.0.
+   */
+  dir: string;
+};
+type GroupOutput = Group[];
+type OnlyCountsOutput = Counts;
+type PathsOutput = string[];
+type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+type WalkerState = {
+  root: string;
+  paths: string[];
+  groups: Group[];
+  counts: Counts;
+  options: Options;
+  queue: Queue;
+  controller: AbortController;
+  symlinks: Map<string, string>;
+  visited: string[];
+};
+type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+type PathSeparator = "/" | "\\";
+type Options<TGlobFunction = unknown> = {
+  includeBasePath?: boolean;
+  includeDirs?: boolean;
+  normalizePath?: boolean;
+  maxDepth: number;
+  maxFiles?: number;
+  resolvePaths?: boolean;
+  suppressErrors: boolean;
+  group?: boolean;
+  onlyCounts?: boolean;
+  filters: FilterPredicate[];
+  resolveSymlinks?: boolean;
+  useRealPaths?: boolean;
+  excludeFiles?: boolean;
+  excludeSymlinks?: boolean;
+  exclude?: ExcludePredicate;
+  relativePaths?: boolean;
+  pathSeparator: PathSeparator;
+  signal?: AbortSignal;
+  globFunction?: TGlobFunction;
+};
+type GlobMatcher = (test: string) => boolean;
+type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+type GlobParams<T> = T extends ((globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher) ? TParams : [];
+//#endregion
+//#region src/builder/api-builder.d.ts
+declare class APIBuilder<TReturnType extends Output> {
+  private readonly root;
+  private readonly options;
+  constructor(root: string, options: Options);
+  withPromise(): Promise<TReturnType>;
+  withCallback(cb: ResultCallback<TReturnType>): void;
+  sync(): TReturnType;
+}
+//#endregion
+//#region src/builder/index.d.ts
+declare class Builder<TReturnType extends Output = PathsOutput, TGlobFunction = typeof picomatch> {
+  private readonly globCache;
+  private options;
+  private globFunction?;
+  constructor(options?: Partial<Options<TGlobFunction>>);
+  group(): Builder<GroupOutput, TGlobFunction>;
+  withPathSeparator(separator: "/" | "\\"): this;
+  withBasePath(): this;
+  withRelativePaths(): this;
+  withDirs(): this;
+  withMaxDepth(depth: number): this;
+  withMaxFiles(limit: number): this;
+  withFullPaths(): this;
+  withErrors(): this;
+  withSymlinks({
+    resolvePaths
+  }?: {
+    resolvePaths?: boolean | undefined;
+  }): this;
+  withAbortSignal(signal: AbortSignal): this;
+  normalize(): this;
+  filter(predicate: FilterPredicate): this;
+  onlyDirs(): this;
+  exclude(predicate: ExcludePredicate): this;
+  onlyCounts(): Builder<OnlyCountsOutput, TGlobFunction>;
+  crawl(root?: string): APIBuilder<TReturnType>;
+  withGlobFunction<TFunc>(fn: TFunc): Builder<TReturnType, TFunc>;
+  /**
+   * @deprecated Pass options using the constructor instead:
+   * ```ts
+   * new fdir(options).crawl("/path/to/root");
+   * ```
+   * This method will be removed in v7.0
+   */
+  crawlWithOptions(root: string, options: Partial<Options<TGlobFunction>>): APIBuilder<TReturnType>;
+  glob(...patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[]): Builder<TReturnType, TGlobFunction>;
+  globWithOptions(patterns: string[], ...options: GlobParams<TGlobFunction>): Builder<TReturnType, TGlobFunction>;
+}
+//#endregion
+//#region src/index.d.ts
+type Fdir = typeof Builder;
+//#endregion
+export { Counts, ExcludePredicate, Fdir, FilterPredicate, GlobFunction, GlobMatcher, GlobParams, Group, GroupOutput, OnlyCountsOutput, Options, Output, PathSeparator, PathsOutput, ResultCallback, WalkerState, Builder as fdir };

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { Builder } from "./builder";
+export { Builder as fdir };
+export type Fdir = typeof Builder;
+export * from "./types";

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fdir = void 0;
+const builder_1 = require("./builder");
+Object.defineProperty(exports, "fdir", { enumerable: true, get: function () { return builder_1.Builder; } });
+__exportStar(require("./types"), exports);

backend/node_modules/tinyglobby/node_modules/fdir/dist/index.mjs

@@ -0,0 +1,554 @@
+import { createRequire } from "module";
+import { basename, dirname, normalize, relative, resolve, sep } from "path";
+import fs from "fs";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/utils.ts
+function cleanPath(path) {
+	let normalized = normalize(path);
+	if (normalized.length > 1 && normalized[normalized.length - 1] === sep) normalized = normalized.substring(0, normalized.length - 1);
+	return normalized;
+}
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+	return path.replace(SLASHES_REGEX, separator);
+}
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+	return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+function normalizePath(path, options) {
+	const { resolvePaths, normalizePath: normalizePath$1, pathSeparator } = options;
+	const pathNeedsCleaning = process.platform === "win32" && path.includes("/") || path.startsWith(".");
+	if (resolvePaths) path = resolve(path);
+	if (normalizePath$1 || pathNeedsCleaning) path = cleanPath(path);
+	if (path === ".") return "";
+	const needsSeperator = path[path.length - 1] !== pathSeparator;
+	return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/join-path.ts
+function joinPathWithBasePath(filename, directoryPath) {
+	return directoryPath + filename;
+}
+function joinPathWithRelativePath(root, options) {
+	return function(filename, directoryPath) {
+		const sameRoot = directoryPath.startsWith(root);
+		if (sameRoot) return directoryPath.replace(root, "") + filename;
+		else return convertSlashes(relative(root, directoryPath), options.pathSeparator) + options.pathSeparator + filename;
+	};
+}
+function joinPath(filename) {
+	return filename;
+}
+function joinDirectoryPath(filename, directoryPath, separator) {
+	return directoryPath + filename + separator;
+}
+function build$7(root, options) {
+	const { relativePaths, includeBasePath } = options;
+	return relativePaths && root ? joinPathWithRelativePath(root, options) : includeBasePath ? joinPathWithBasePath : joinPath;
+}
+
+//#endregion
+//#region src/api/functions/push-directory.ts
+function pushDirectoryWithRelativePath(root) {
+	return function(directoryPath, paths) {
+		paths.push(directoryPath.substring(root.length) || ".");
+	};
+}
+function pushDirectoryFilterWithRelativePath(root) {
+	return function(directoryPath, paths, filters) {
+		const relativePath = directoryPath.substring(root.length) || ".";
+		if (filters.every((filter) => filter(relativePath, true))) paths.push(relativePath);
+	};
+}
+const pushDirectory = (directoryPath, paths) => {
+	paths.push(directoryPath || ".");
+};
+const pushDirectoryFilter = (directoryPath, paths, filters) => {
+	const path = directoryPath || ".";
+	if (filters.every((filter) => filter(path, true))) paths.push(path);
+};
+const empty$2 = () => {};
+function build$6(root, options) {
+	const { includeDirs, filters, relativePaths } = options;
+	if (!includeDirs) return empty$2;
+	if (relativePaths) return filters && filters.length ? pushDirectoryFilterWithRelativePath(root) : pushDirectoryWithRelativePath(root);
+	return filters && filters.length ? pushDirectoryFilter : pushDirectory;
+}
+
+//#endregion
+//#region src/api/functions/push-file.ts
+const pushFileFilterAndCount = (filename, _paths, counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) counts.files++;
+};
+const pushFileFilter = (filename, paths, _counts, filters) => {
+	if (filters.every((filter) => filter(filename, false))) paths.push(filename);
+};
+const pushFileCount = (_filename, _paths, counts, _filters) => {
+	counts.files++;
+};
+const pushFile = (filename, paths) => {
+	paths.push(filename);
+};
+const empty$1 = () => {};
+function build$5(options) {
+	const { excludeFiles, filters, onlyCounts } = options;
+	if (excludeFiles) return empty$1;
+	if (filters && filters.length) return onlyCounts ? pushFileFilterAndCount : pushFileFilter;
+	else if (onlyCounts) return pushFileCount;
+	else return pushFile;
+}
+
+//#endregion
+//#region src/api/functions/get-array.ts
+const getArray = (paths) => {
+	return paths;
+};
+const getArrayGroup = () => {
+	return [""].slice(0, 0);
+};
+function build$4(options) {
+	return options.group ? getArrayGroup : getArray;
+}
+
+//#endregion
+//#region src/api/functions/group-files.ts
+const groupFiles = (groups, directory, files) => {
+	groups.push({
+		directory,
+		files,
+		dir: directory
+	});
+};
+const empty = () => {};
+function build$3(options) {
+	return options.group ? groupFiles : empty;
+}
+
+//#endregion
+//#region src/api/functions/resolve-symlink.ts
+const resolveSymlinksAsync = function(path, state, callback$1) {
+	const { queue, options: { suppressErrors } } = state;
+	queue.enqueue();
+	fs.realpath(path, (error, resolvedPath) => {
+		if (error) return queue.dequeue(suppressErrors ? null : error, state);
+		fs.stat(resolvedPath, (error$1, stat) => {
+			if (error$1) return queue.dequeue(suppressErrors ? null : error$1, state);
+			if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return queue.dequeue(null, state);
+			callback$1(stat, resolvedPath);
+			queue.dequeue(null, state);
+		});
+	});
+};
+const resolveSymlinks = function(path, state, callback$1) {
+	const { queue, options: { suppressErrors } } = state;
+	queue.enqueue();
+	try {
+		const resolvedPath = fs.realpathSync(path);
+		const stat = fs.statSync(resolvedPath);
+		if (stat.isDirectory() && isRecursive(path, resolvedPath, state)) return;
+		callback$1(stat, resolvedPath);
+	} catch (e) {
+		if (!suppressErrors) throw e;
+	}
+};
+function build$2(options, isSynchronous) {
+	if (!options.resolveSymlinks || options.excludeSymlinks) return null;
+	return isSynchronous ? resolveSymlinks : resolveSymlinksAsync;
+}
+function isRecursive(path, resolved, state) {
+	if (state.options.useRealPaths) return isRecursiveUsingRealPaths(resolved, state);
+	let parent = dirname(path);
+	let depth = 1;
+	while (parent !== state.root && depth < 2) {
+		const resolvedPath = state.symlinks.get(parent);
+		const isSameRoot = !!resolvedPath && (resolvedPath === resolved || resolvedPath.startsWith(resolved) || resolved.startsWith(resolvedPath));
+		if (isSameRoot) depth++;
+		else parent = dirname(parent);
+	}
+	state.symlinks.set(path, resolved);
+	return depth > 1;
+}
+function isRecursiveUsingRealPaths(resolved, state) {
+	return state.visited.includes(resolved + state.options.pathSeparator);
+}
+
+//#endregion
+//#region src/api/functions/invoke-callback.ts
+const onlyCountsSync = (state) => {
+	return state.counts;
+};
+const groupsSync = (state) => {
+	return state.groups;
+};
+const defaultSync = (state) => {
+	return state.paths;
+};
+const limitFilesSync = (state) => {
+	return state.paths.slice(0, state.options.maxFiles);
+};
+const onlyCountsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.counts, state.options.suppressErrors);
+	return null;
+};
+const defaultAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths, state.options.suppressErrors);
+	return null;
+};
+const limitFilesAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.paths.slice(0, state.options.maxFiles), state.options.suppressErrors);
+	return null;
+};
+const groupsAsync = (state, error, callback$1) => {
+	report(error, callback$1, state.groups, state.options.suppressErrors);
+	return null;
+};
+function report(error, callback$1, output, suppressErrors) {
+	if (error && !suppressErrors) callback$1(error, output);
+	else callback$1(null, output);
+}
+function build$1(options, isSynchronous) {
+	const { onlyCounts, group, maxFiles } = options;
+	if (onlyCounts) return isSynchronous ? onlyCountsSync : onlyCountsAsync;
+	else if (group) return isSynchronous ? groupsSync : groupsAsync;
+	else if (maxFiles) return isSynchronous ? limitFilesSync : limitFilesAsync;
+	else return isSynchronous ? defaultSync : defaultAsync;
+}
+
+//#endregion
+//#region src/api/functions/walk-directory.ts
+const readdirOpts = { withFileTypes: true };
+const walkAsync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	state.queue.enqueue();
+	if (currentDepth <= 0) return state.queue.dequeue(null, state);
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	fs.readdir(crawlPath || ".", readdirOpts, (error, entries = []) => {
+		callback$1(entries, directoryPath, currentDepth);
+		state.queue.dequeue(state.options.suppressErrors ? null : error, state);
+	});
+};
+const walkSync = (state, crawlPath, directoryPath, currentDepth, callback$1) => {
+	if (currentDepth <= 0) return;
+	state.visited.push(crawlPath);
+	state.counts.directories++;
+	let entries = [];
+	try {
+		entries = fs.readdirSync(crawlPath || ".", readdirOpts);
+	} catch (e) {
+		if (!state.options.suppressErrors) throw e;
+	}
+	callback$1(entries, directoryPath, currentDepth);
+};
+function build(isSynchronous) {
+	return isSynchronous ? walkSync : walkAsync;
+}
+
+//#endregion
+//#region src/api/queue.ts
+/**
+* This is a custom stateless queue to track concurrent async fs calls.
+* It increments a counter whenever a call is queued and decrements it
+* as soon as it completes. When the counter hits 0, it calls onQueueEmpty.
+*/
+var Queue = class {
+	count = 0;
+	constructor(onQueueEmpty) {
+		this.onQueueEmpty = onQueueEmpty;
+	}
+	enqueue() {
+		this.count++;
+		return this.count;
+	}
+	dequeue(error, output) {
+		if (this.onQueueEmpty && (--this.count <= 0 || error)) {
+			this.onQueueEmpty(error, output);
+			if (error) {
+				output.controller.abort();
+				this.onQueueEmpty = void 0;
+			}
+		}
+	}
+};
+
+//#endregion
+//#region src/api/counter.ts
+var Counter = class {
+	_files = 0;
+	_directories = 0;
+	set files(num) {
+		this._files = num;
+	}
+	get files() {
+		return this._files;
+	}
+	set directories(num) {
+		this._directories = num;
+	}
+	get directories() {
+		return this._directories;
+	}
+	/**
+	* @deprecated use `directories` instead
+	*/
+	/* c8 ignore next 3 */
+	get dirs() {
+		return this._directories;
+	}
+};
+
+//#endregion
+//#region src/api/walker.ts
+var Walker = class {
+	root;
+	isSynchronous;
+	state;
+	joinPath;
+	pushDirectory;
+	pushFile;
+	getArray;
+	groupFiles;
+	resolveSymlink;
+	walkDirectory;
+	callbackInvoker;
+	constructor(root, options, callback$1) {
+		this.isSynchronous = !callback$1;
+		this.callbackInvoker = build$1(options, this.isSynchronous);
+		this.root = normalizePath(root, options);
+		this.state = {
+			root: isRootDirectory(this.root) ? this.root : this.root.slice(0, -1),
+			paths: [""].slice(0, 0),
+			groups: [],
+			counts: new Counter(),
+			options,
+			queue: new Queue((error, state) => this.callbackInvoker(state, error, callback$1)),
+			symlinks: /* @__PURE__ */ new Map(),
+			visited: [""].slice(0, 0),
+			controller: new AbortController()
+		};
+		this.joinPath = build$7(this.root, options);
+		this.pushDirectory = build$6(this.root, options);
+		this.pushFile = build$5(options);
+		this.getArray = build$4(options);
+		this.groupFiles = build$3(options);
+		this.resolveSymlink = build$2(options, this.isSynchronous);
+		this.walkDirectory = build(this.isSynchronous);
+	}
+	start() {
+		this.pushDirectory(this.root, this.state.paths, this.state.options.filters);
+		this.walkDirectory(this.state, this.root, this.root, this.state.options.maxDepth, this.walk);
+		return this.isSynchronous ? this.callbackInvoker(this.state, null) : null;
+	}
+	walk = (entries, directoryPath, depth) => {
+		const { paths, options: { filters, resolveSymlinks: resolveSymlinks$1, excludeSymlinks, exclude, maxFiles, signal, useRealPaths, pathSeparator }, controller } = this.state;
+		if (controller.signal.aborted || signal && signal.aborted || maxFiles && paths.length > maxFiles) return;
+		const files = this.getArray(this.state.paths);
+		for (let i = 0; i < entries.length; ++i) {
+			const entry = entries[i];
+			if (entry.isFile() || entry.isSymbolicLink() && !resolveSymlinks$1 && !excludeSymlinks) {
+				const filename = this.joinPath(entry.name, directoryPath);
+				this.pushFile(filename, files, this.state.counts, filters);
+			} else if (entry.isDirectory()) {
+				let path = joinDirectoryPath(entry.name, directoryPath, this.state.options.pathSeparator);
+				if (exclude && exclude(entry.name, path)) continue;
+				this.pushDirectory(path, paths, filters);
+				this.walkDirectory(this.state, path, path, depth - 1, this.walk);
+			} else if (this.resolveSymlink && entry.isSymbolicLink()) {
+				let path = joinPathWithBasePath(entry.name, directoryPath);
+				this.resolveSymlink(path, this.state, (stat, resolvedPath) => {
+					if (stat.isDirectory()) {
+						resolvedPath = normalizePath(resolvedPath, this.state.options);
+						if (exclude && exclude(entry.name, useRealPaths ? resolvedPath : path + pathSeparator)) return;
+						this.walkDirectory(this.state, resolvedPath, useRealPaths ? resolvedPath : path + pathSeparator, depth - 1, this.walk);
+					} else {
+						resolvedPath = useRealPaths ? resolvedPath : path;
+						const filename = basename(resolvedPath);
+						const directoryPath$1 = normalizePath(dirname(resolvedPath), this.state.options);
+						resolvedPath = this.joinPath(filename, directoryPath$1);
+						this.pushFile(resolvedPath, files, this.state.counts, filters);
+					}
+				});
+			}
+		}
+		this.groupFiles(this.state.groups, directoryPath, files);
+	};
+};
+
+//#endregion
+//#region src/api/async.ts
+function promise(root, options) {
+	return new Promise((resolve$1, reject) => {
+		callback(root, options, (err, output) => {
+			if (err) return reject(err);
+			resolve$1(output);
+		});
+	});
+}
+function callback(root, options, callback$1) {
+	let walker = new Walker(root, options, callback$1);
+	walker.start();
+}
+
+//#endregion
+//#region src/api/sync.ts
+function sync(root, options) {
+	const walker = new Walker(root, options);
+	return walker.start();
+}
+
+//#endregion
+//#region src/builder/api-builder.ts
+var APIBuilder = class {
+	constructor(root, options) {
+		this.root = root;
+		this.options = options;
+	}
+	withPromise() {
+		return promise(this.root, this.options);
+	}
+	withCallback(cb) {
+		callback(this.root, this.options, cb);
+	}
+	sync() {
+		return sync(this.root, this.options);
+	}
+};
+
+//#endregion
+//#region src/builder/index.ts
+var pm = null;
+/* c8 ignore next 6 */
+try {
+	__require.resolve("picomatch");
+	pm = __require("picomatch");
+} catch (_e) {}
+var Builder = class {
+	globCache = {};
+	options = {
+		maxDepth: Infinity,
+		suppressErrors: true,
+		pathSeparator: sep,
+		filters: []
+	};
+	globFunction;
+	constructor(options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		this.globFunction = this.options.globFunction;
+	}
+	group() {
+		this.options.group = true;
+		return this;
+	}
+	withPathSeparator(separator) {
+		this.options.pathSeparator = separator;
+		return this;
+	}
+	withBasePath() {
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withRelativePaths() {
+		this.options.relativePaths = true;
+		return this;
+	}
+	withDirs() {
+		this.options.includeDirs = true;
+		return this;
+	}
+	withMaxDepth(depth) {
+		this.options.maxDepth = depth;
+		return this;
+	}
+	withMaxFiles(limit) {
+		this.options.maxFiles = limit;
+		return this;
+	}
+	withFullPaths() {
+		this.options.resolvePaths = true;
+		this.options.includeBasePath = true;
+		return this;
+	}
+	withErrors() {
+		this.options.suppressErrors = false;
+		return this;
+	}
+	withSymlinks({ resolvePaths = true } = {}) {
+		this.options.resolveSymlinks = true;
+		this.options.useRealPaths = resolvePaths;
+		return this.withFullPaths();
+	}
+	withAbortSignal(signal) {
+		this.options.signal = signal;
+		return this;
+	}
+	normalize() {
+		this.options.normalizePath = true;
+		return this;
+	}
+	filter(predicate) {
+		this.options.filters.push(predicate);
+		return this;
+	}
+	onlyDirs() {
+		this.options.excludeFiles = true;
+		this.options.includeDirs = true;
+		return this;
+	}
+	exclude(predicate) {
+		this.options.exclude = predicate;
+		return this;
+	}
+	onlyCounts() {
+		this.options.onlyCounts = true;
+		return this;
+	}
+	crawl(root) {
+		return new APIBuilder(root || ".", this.options);
+	}
+	withGlobFunction(fn) {
+		this.globFunction = fn;
+		return this;
+	}
+	/**
+	* @deprecated Pass options using the constructor instead:
+	* ```ts
+	* new fdir(options).crawl("/path/to/root");
+	* ```
+	* This method will be removed in v7.0
+	*/
+	/* c8 ignore next 4 */
+	crawlWithOptions(root, options) {
+		this.options = {
+			...this.options,
+			...options
+		};
+		return new APIBuilder(root || ".", this.options);
+	}
+	glob(...patterns) {
+		if (this.globFunction) return this.globWithOptions(patterns);
+		return this.globWithOptions(patterns, ...[{ dot: true }]);
+	}
+	globWithOptions(patterns, ...options) {
+		const globFn = this.globFunction || pm;
+		/* c8 ignore next 5 */
+		if (!globFn) throw new Error("Please specify a glob function to use glob matching.");
+		var isMatch = this.globCache[patterns.join("\0")];
+		if (!isMatch) {
+			isMatch = globFn(patterns, ...options);
+			this.globCache[patterns.join("\0")] = isMatch;
+		}
+		this.options.filters.push((path) => isMatch(path));
+		return this;
+	}
+};
+
+//#endregion
+export { Builder as fdir };

backend/node_modules/tinyglobby/node_modules/fdir/dist/types.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" />
+import { Queue } from "./api/queue";
+export type Counts = {
+    files: number;
+    directories: number;
+    /**
+     * @deprecated use `directories` instead. Will be removed in v7.0.
+     */
+    dirs: number;
+};
+export type Group = {
+    directory: string;
+    files: string[];
+    /**
+     * @deprecated use `directory` instead. Will be removed in v7.0.
+     */
+    dir: string;
+};
+export type GroupOutput = Group[];
+export type OnlyCountsOutput = Counts;
+export type PathsOutput = string[];
+export type Output = OnlyCountsOutput | PathsOutput | GroupOutput;
+export type WalkerState = {
+    root: string;
+    paths: string[];
+    groups: Group[];
+    counts: Counts;
+    options: Options;
+    queue: Queue;
+    controller: AbortController;
+    symlinks: Map<string, string>;
+    visited: string[];
+};
+export type ResultCallback<TOutput extends Output> = (error: Error | null, output: TOutput) => void;
+export type FilterPredicate = (path: string, isDirectory: boolean) => boolean;
+export type ExcludePredicate = (dirName: string, dirPath: string) => boolean;
+export type PathSeparator = "/" | "\\";
+export type Options<TGlobFunction = unknown> = {
+    includeBasePath?: boolean;
+    includeDirs?: boolean;
+    normalizePath?: boolean;
+    maxDepth: number;
+    maxFiles?: number;
+    resolvePaths?: boolean;
+    suppressErrors: boolean;
+    group?: boolean;
+    onlyCounts?: boolean;
+    filters: FilterPredicate[];
+    resolveSymlinks?: boolean;
+    useRealPaths?: boolean;
+    excludeFiles?: boolean;
+    excludeSymlinks?: boolean;
+    exclude?: ExcludePredicate;
+    relativePaths?: boolean;
+    pathSeparator: PathSeparator;
+    signal?: AbortSignal;
+    globFunction?: TGlobFunction;
+};
+export type GlobMatcher = (test: string) => boolean;
+export type GlobFunction = (glob: string | string[], ...params: unknown[]) => GlobMatcher;
+export type GlobParams<T> = T extends (globs: string | string[], ...params: infer TParams extends unknown[]) => GlobMatcher ? TParams : [];

backend/node_modules/tinyglobby/node_modules/fdir/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

backend/node_modules/tinyglobby/node_modules/fdir/dist/utils.d.ts

@@ -0,0 +1,9 @@
+import { PathSeparator } from "./types";
+export declare function cleanPath(path: string): string;
+export declare function convertSlashes(path: string, separator: PathSeparator): string;
+export declare function isRootDirectory(path: string): boolean;
+export declare function normalizePath(path: string, options: {
+    resolvePaths?: boolean;
+    normalizePath?: boolean;
+    pathSeparator: PathSeparator;
+}): string;

backend/node_modules/tinyglobby/node_modules/fdir/dist/utils.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = exports.isRootDirectory = exports.convertSlashes = exports.cleanPath = void 0;
+const path_1 = require("path");
+function cleanPath(path) {
+    let normalized = (0, path_1.normalize)(path);
+    // we have to remove the last path separator
+    // to account for / root path
+    if (normalized.length > 1 && normalized[normalized.length - 1] === path_1.sep)
+        normalized = normalized.substring(0, normalized.length - 1);
+    return normalized;
+}
+exports.cleanPath = cleanPath;
+const SLASHES_REGEX = /[\\/]/g;
+function convertSlashes(path, separator) {
+    return path.replace(SLASHES_REGEX, separator);
+}
+exports.convertSlashes = convertSlashes;
+const WINDOWS_ROOT_DIR_REGEX = /^[a-z]:[\\/]$/i;
+function isRootDirectory(path) {
+    return path === "/" || WINDOWS_ROOT_DIR_REGEX.test(path);
+}
+exports.isRootDirectory = isRootDirectory;
+function normalizePath(path, options) {
+    const { resolvePaths, normalizePath, pathSeparator } = options;
+    const pathNeedsCleaning = (process.platform === "win32" && path.includes("/")) ||
+        path.startsWith(".");
+    if (resolvePaths)
+        path = (0, path_1.resolve)(path);
+    if (normalizePath || pathNeedsCleaning)
+        path = cleanPath(path);
+    if (path === ".")
+        return "";
+    const needsSeperator = path[path.length - 1] !== pathSeparator;
+    return convertSlashes(needsSeperator ? path + pathSeparator : path, pathSeparator);
+}
+exports.normalizePath = normalizePath;

backend/node_modules/tinyglobby/node_modules/fdir/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "fdir",
+  "version": "6.4.6",
+  "description": "The fastest directory crawler & globbing alternative to glob, fast-glob, & tiny-glob. Crawls 1m files in < 1s",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "prepublishOnly": "npm run test && npm run build",
+    "build": "tsc",
+    "format": "prettier --write src __tests__ benchmarks",
+    "test": "vitest run __tests__/",
+    "test:coverage": "vitest run --coverage __tests__/",
+    "test:watch": "vitest __tests__/",
+    "bench": "ts-node benchmarks/benchmark.js",
+    "bench:glob": "ts-node benchmarks/glob-benchmark.ts",
+    "bench:fdir": "ts-node benchmarks/fdir-benchmark.ts",
+    "release": "./scripts/release.sh"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/thecodrr/fdir.git"
+  },
+  "keywords": [
+    "util",
+    "os",
+    "sys",
+    "fs",
+    "walk",
+    "crawler",
+    "directory",
+    "files",
+    "io",
+    "tiny-glob",
+    "glob",
+    "fast-glob",
+    "speed",
+    "javascript",
+    "nodejs"
+  ],
+  "author": "thecodrr <thecodrr@protonmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/thecodrr/fdir/issues"
+  },
+  "homepage": "https://github.com/thecodrr/fdir#readme",
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/mock-fs": "^4.13.4",
+    "@types/node": "^20.9.4",
+    "@types/picomatch": "^3.0.0",
+    "@types/tap": "^15.0.11",
+    "@vitest/coverage-v8": "^0.34.6",
+    "all-files-in-tree": "^1.1.2",
+    "benny": "^3.7.1",
+    "csv-to-markdown-table": "^1.3.1",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.3.2",
+    "fdir1": "npm:fdir@1.2.0",
+    "fdir2": "npm:fdir@2.1.0",
+    "fdir3": "npm:fdir@3.4.2",
+    "fdir4": "npm:fdir@4.1.0",
+    "fdir5": "npm:fdir@5.0.0",
+    "fs-readdir-recursive": "^1.1.0",
+    "get-all-files": "^4.1.0",
+    "glob": "^10.3.10",
+    "klaw-sync": "^6.0.0",
+    "mock-fs": "^5.2.0",
+    "picomatch": "^4.0.2",
+    "prettier": "^3.5.3",
+    "recur-readdir": "0.0.1",
+    "recursive-files": "^1.0.2",
+    "recursive-fs": "^2.1.0",
+    "recursive-readdir": "^2.2.3",
+    "rrdir": "^12.1.0",
+    "systeminformation": "^5.21.17",
+    "tiny-glob": "^0.2.9",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.3.2",
+    "vitest": "^0.34.6",
+    "walk-sync": "^3.0.0"
+  },
+  "peerDependencies": {
+    "picomatch": "^3 || ^4"
+  },
+  "peerDependenciesMeta": {
+    "picomatch": {
+      "optional": true
+    }
+  }
+}

backend/node_modules/tinyglobby/node_modules/picomatch/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017-present, Jon Schlinkert.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

backend/node_modules/tinyglobby/node_modules/picomatch/README.md

@@ -0,0 +1,738 @@
+<h1 align="center">Picomatch</h1>
+
+<p align="center">
+<a href="https://npmjs.org/package/picomatch">
+<img src="https://img.shields.io/npm/v/picomatch.svg" alt="version">
+</a>
+<a href="https://github.com/micromatch/picomatch/actions?workflow=Tests">
+<img src="https://github.com/micromatch/picomatch/workflows/Tests/badge.svg" alt="test status">
+</a>
+<a href="https://coveralls.io/github/micromatch/picomatch">
+<img src="https://img.shields.io/coveralls/github/micromatch/picomatch/master.svg" alt="coverage status">
+</a>
+<a href="https://npmjs.org/package/picomatch">
+<img src="https://img.shields.io/npm/dm/picomatch.svg" alt="downloads">
+</a>
+</p>
+
+<br>
+<br>
+
+<p align="center">
+<strong>Blazing fast and accurate glob matcher written in JavaScript.</strong></br>
+<em>No dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.</em>
+</p>
+
+<br>
+<br>
+
+## Why picomatch?
+
+* **Lightweight** - No dependencies
+* **Minimal** - Tiny API surface. Main export is a function that takes a glob pattern and returns a matcher function.
+* **Fast** - Loads in about 2ms (that's several times faster than a [single frame of a HD movie](http://www.endmemo.com/sconvert/framespersecondframespermillisecond.php) at 60fps)
+* **Performant** - Use the returned matcher function to speed up repeat matching (like when watching files)
+* **Accurate matching** - Using wildcards (`*` and `?`), globstars (`**`) for nested directories, [advanced globbing](#advanced-globbing) with extglobs, braces, and POSIX brackets, and support for escaping special characters with `\` or quotes.
+* **Well tested** - Thousands of unit tests
+
+See the [library comparison](#library-comparisons) to other libraries.
+
+<br>
+<br>
+
+## Table of Contents
+
+<details><summary> Click to expand </summary>
+
+- [Install](#install)
+- [Usage](#usage)
+- [API](#api)
+  * [picomatch](#picomatch)
+  * [.test](#test)
+  * [.matchBase](#matchbase)
+  * [.isMatch](#ismatch)
+  * [.parse](#parse)
+  * [.scan](#scan)
+  * [.compileRe](#compilere)
+  * [.makeRe](#makere)
+  * [.toRegex](#toregex)
+- [Options](#options)
+  * [Picomatch options](#picomatch-options)
+  * [Scan Options](#scan-options)
+  * [Options Examples](#options-examples)
+- [Globbing features](#globbing-features)
+  * [Basic globbing](#basic-globbing)
+  * [Advanced globbing](#advanced-globbing)
+  * [Braces](#braces)
+  * [Matching special characters as literals](#matching-special-characters-as-literals)
+- [Library Comparisons](#library-comparisons)
+- [Benchmarks](#benchmarks)
+- [Philosophies](#philosophies)
+- [About](#about)
+  * [Author](#author)
+  * [License](#license)
+
+_(TOC generated by [verb](https://github.com/verbose/verb) using [markdown-toc](https://github.com/jonschlinkert/markdown-toc))_
+
+</details>
+
+<br>
+<br>
+
+## Install
+
+Install with [npm](https://www.npmjs.com/):
+
+```sh
+npm install --save picomatch
+```
+
+<br>
+
+## Usage
+
+The main export is a function that takes a glob pattern and an options object and returns a function for matching strings.
+
+```js
+const pm = require('picomatch');
+const isMatch = pm('*.js');
+
+console.log(isMatch('abcd')); //=> false
+console.log(isMatch('a.js')); //=> true
+console.log(isMatch('a.md')); //=> false
+console.log(isMatch('a/b.js')); //=> false
+```
+
+<br>
+
+## API
+
+### [picomatch](lib/picomatch.js#L31)
+
+Creates a matcher function from one or more glob patterns. The returned function takes a string to match as its first argument, and returns true if the string is a match. The returned matcher function also takes a boolean as the second argument that, when true, returns an object with additional information.
+
+**Params**
+
+* `globs` **{String|Array}**: One or more glob patterns.
+* `options` **{Object=}**
+* `returns` **{Function=}**: Returns a matcher function.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch(glob[, options]);
+
+const isMatch = picomatch('*.!(*a)');
+console.log(isMatch('a.a')); //=> false
+console.log(isMatch('a.b')); //=> true
+```
+
+**Example without node.js**
+
+For environments without `node.js`, `picomatch/posix` provides you a dependency-free matcher, without automatic OS detection.
+
+```js
+const picomatch = require('picomatch/posix');
+// the same API, defaulting to posix paths
+const isMatch = picomatch('a/*');
+console.log(isMatch('a\\b')); //=> false
+console.log(isMatch('a/b')); //=> true
+
+// you can still configure the matcher function to accept windows paths
+const isMatch = picomatch('a/*', { options: windows });
+console.log(isMatch('a\\b')); //=> true
+console.log(isMatch('a/b')); //=> true
+```
+
+### [.test](lib/picomatch.js#L116)
+
+Test `input` with the given `regex`. This is used by the main `picomatch()` function to test the input string.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `regex` **{RegExp}**
+* `returns` **{Object}**: Returns an object with matching info.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.test(input, regex[, options]);
+
+console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+// { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+```
+
+### [.matchBase](lib/picomatch.js#L160)
+
+Match the basename of a filepath.
+
+**Params**
+
+* `input` **{String}**: String to test.
+* `glob` **{RegExp|String}**: Glob pattern or regex created by [.makeRe](#makeRe).
+* `returns` **{Boolean}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.matchBase(input, glob[, options]);
+console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+```
+
+### [.isMatch](lib/picomatch.js#L182)
+
+Returns true if **any** of the given glob `patterns` match the specified `string`.
+
+**Params**
+
+* **{String|Array}**: str The string to test.
+* **{String|Array}**: patterns One or more glob patterns to use for matching.
+* **{Object}**: See available [options](#options).
+* `returns` **{Boolean}**: Returns true if any patterns match `str`
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.isMatch(string, patterns[, options]);
+
+console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+```
+
+### [.parse](lib/picomatch.js#L198)
+
+Parse a glob pattern to create the source string for a regular expression.
+
+**Params**
+
+* `pattern` **{String}**
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with useful properties and output to be used as a regex source string.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.parse(pattern[, options]);
+```
+
+### [.scan](lib/picomatch.js#L230)
+
+Scan a glob pattern to separate the pattern into segments.
+
+**Params**
+
+* `input` **{String}**: Glob pattern to scan.
+* `options` **{Object}**
+* `returns` **{Object}**: Returns an object with
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.scan(input[, options]);
+
+const result = picomatch.scan('!./foo/*.js');
+console.log(result);
+{ prefix: '!./',
+  input: '!./foo/*.js',
+  start: 3,
+  base: 'foo',
+  glob: '*.js',
+  isBrace: false,
+  isBracket: false,
+  isGlob: true,
+  isExtglob: false,
+  isGlobstar: false,
+  negated: true }
+```
+
+### [.compileRe](lib/picomatch.js#L244)
+
+Compile a regular expression from the `state` object returned by the
+[parse()](#parse) method.
+
+**Params**
+
+* `state` **{Object}**
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Intended for implementors, this argument allows you to return the raw output from the parser.
+* `returnState` **{Boolean}**: Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+* `returns` **{RegExp}**
+
+### [.makeRe](lib/picomatch.js#L285)
+
+Create a regular expression from a parsed glob pattern.
+
+**Params**
+
+* `state` **{String}**: The object returned from the `.parse` method.
+* `options` **{Object}**
+* `returnOutput` **{Boolean}**: Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+* `returnState` **{Boolean}**: Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+* `returns` **{RegExp}**: Returns a regex created from the given pattern.
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const state = picomatch.parse('*.js');
+// picomatch.compileRe(state[, options]);
+
+console.log(picomatch.compileRe(state));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+### [.toRegex](lib/picomatch.js#L320)
+
+Create a regular expression from the given regex source string.
+
+**Params**
+
+* `source` **{String}**: Regular expression source string.
+* `options` **{Object}**
+* `returns` **{RegExp}**
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+// picomatch.toRegex(source[, options]);
+
+const { output } = picomatch.parse('*.js');
+console.log(picomatch.toRegex(output));
+//=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+```
+
+<br>
+
+## Options
+
+### Picomatch options
+
+The following options may be used with the main `picomatch()` function or any of the methods on the picomatch API.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `basename`            | `boolean`      | `false`     | If set, then patterns without slashes will be matched against the basename of the path if it contains slashes.  For example, `a?b` would match the path `/xyz/123/acb`, but not `/xyz/acb/123`. |
+| `bash`                | `boolean`      | `false`     | Follow bash matching rules more strictly - disallows backslashes as escape characters, and treats single stars as globstars (`**`). |
+| `capture`             | `boolean`      | `undefined` | Return regex matches in supporting methods. |
+| `contains`            | `boolean`      | `undefined` | Allows glob to match any part of the given string(s). |
+| `cwd`                 | `string`       | `process.cwd()` | Current working directory. Used by `picomatch.split()` |
+| `debug`               | `boolean`      | `undefined` | Debug regular expressions when an error is thrown. |
+| `dot`                 | `boolean`      | `false`     | Enable dotfile matching. By default, dotfiles are ignored unless a `.` is explicitly defined in the pattern, or `options.dot` is true |
+| `expandRange`         | `function`     | `undefined` | Custom function for expanding ranges in brace patterns, such as `{a..z}`. The function receives the range values as two arguments, and it must return a string to be used in the generated regex. It's recommended that returned strings be wrapped in parentheses. |
+| `failglob`            | `boolean`      | `false`     | Throws an error if no matches are found. Based on the bash option of the same name. |
+| `fastpaths`           | `boolean`      | `true`      | To speed up processing, full parsing is skipped for a handful common glob patterns. Disable this behavior by setting this option to `false`. |
+| `flags`               | `string`      | `undefined` | Regex flags to use in the generated regex. If defined, the `nocase` option will be overridden. |
+| [format](#optionsformat) | `function` | `undefined` | Custom function for formatting the returned string. This is useful for removing leading slashes, converting Windows paths to Posix paths, etc. |
+| `ignore`              | `array\|string` | `undefined` | One or more glob patterns for excluding strings that should not be matched from the result. |
+| `keepQuotes`          | `boolean`      | `false`     | Retain quotes in the generated regex, since quotes may also be used as an alternative to backslashes.  |
+| `literalBrackets`     | `boolean`      | `undefined` | When `true`, brackets in the glob pattern will be escaped so that only literal brackets will be matched. |
+| `matchBase`           | `boolean`      | `false`     | Alias for `basename` |
+| `maxLength`           | `boolean`      | `65536`     | Limit the max length of the input string. An error is thrown if the input string is longer than this value. |
+| `nobrace`             | `boolean`      | `false`     | Disable brace matching, so that `{a,b}` and `{1..3}` would be treated as literal characters. |
+| `nobracket`           | `boolean`      | `undefined` | Disable matching with regex brackets. |
+| `nocase`              | `boolean`      | `false`     | Make matching case-insensitive. Equivalent to the regex `i` flag. Note that this option is overridden by the `flags` option. |
+| `nodupes`             | `boolean`      | `true`      | Deprecated, use `nounique` instead. This option will be removed in a future major release. By default duplicates are removed. Disable uniquification by setting this option to false. |
+| `noext`               | `boolean`      | `false`     | Alias for `noextglob` |
+| `noextglob`           | `boolean`      | `false`     | Disable support for matching with extglobs (like `+(a\|b)`) |
+| `noglobstar`          | `boolean`      | `false`     | Disable support for matching nested directories with globstars (`**`) |
+| `nonegate`            | `boolean`      | `false`     | Disable support for negating with leading `!` |
+| `noquantifiers`       | `boolean`      | `false`     | Disable support for regex quantifiers (like `a{1,2}`) and treat them as brace patterns to be expanded. |
+| [onIgnore](#optionsonIgnore) | `function` | `undefined` | Function to be called on ignored items. |
+| [onMatch](#optionsonMatch) | `function` | `undefined` | Function to be called on matched items. |
+| [onResult](#optionsonResult) | `function` | `undefined` | Function to be called on all items, regardless of whether or not they are matched or ignored. |
+| `posix`               | `boolean`      | `false`     | Support POSIX character classes ("posix brackets"). |
+| `posixSlashes`        | `boolean`      | `undefined` | Convert all slashes in file paths to forward slashes. This does not convert slashes in the glob pattern itself |
+| `prepend`             | `boolean`      | `undefined` | String to prepend to the generated regex used for matching. |
+| `regex`               | `boolean`      | `false`     | Use regular expression rules for `+` (instead of matching literal `+`), and for stars that follow closing parentheses or brackets (as in `)*` and `]*`). |
+| `strictBrackets`      | `boolean`      | `undefined` | Throw an error if brackets, braces, or parens are imbalanced. |
+| `strictSlashes`       | `boolean`      | `undefined` | When true, picomatch won't match trailing slashes with single stars. |
+| `unescape`            | `boolean`      | `undefined` | Remove backslashes preceding escaped characters in the glob pattern. By default, backslashes are retained. |
+| `unixify`             | `boolean`      | `undefined` | Alias for `posixSlashes`, for backwards compatibility. |
+| `windows`             | `boolean`      | `false`     | Also accept backslashes as the path separator. |
+
+### Scan Options
+
+In addition to the main [picomatch options](#picomatch-options), the following options may also be used with the [.scan](#scan) method.
+
+| **Option** | **Type** | **Default value** | **Description** |
+| --- | --- | --- | --- |
+| `tokens` | `boolean` | `false` | When `true`, the returned object will include an array of tokens (objects), representing each path "segment" in the scanned glob pattern |
+| `parts` | `boolean` | `false` | When `true`, the returned object will include an array of strings representing each path "segment" in the scanned glob pattern. This is automatically enabled when `options.tokens` is true |
+
+**Example**
+
+```js
+const picomatch = require('picomatch');
+const result = picomatch.scan('!./foo/*.js', { tokens: true });
+console.log(result);
+// {
+//   prefix: '!./',
+//   input: '!./foo/*.js',
+//   start: 3,
+//   base: 'foo',
+//   glob: '*.js',
+//   isBrace: false,
+//   isBracket: false,
+//   isGlob: true,
+//   isExtglob: false,
+//   isGlobstar: false,
+//   negated: true,
+//   maxDepth: 2,
+//   tokens: [
+//     { value: '!./', depth: 0, isGlob: false, negated: true, isPrefix: true },
+//     { value: 'foo', depth: 1, isGlob: false },
+//     { value: '*.js', depth: 1, isGlob: true }
+//   ],
+//   slashes: [ 2, 6 ],
+//   parts: [ 'foo', '*.js' ]
+// }
+```
+
+<br>
+
+### Options Examples
+
+#### options.expandRange
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for expanding ranges in brace patterns. The [fill-range](https://github.com/jonschlinkert/fill-range) library is ideal for this purpose, or you can use custom code to do whatever you need.
+
+**Example**
+
+The following example shows how to create a glob that matches a folder
+
+```js
+const fill = require('fill-range');
+const regex = pm.makeRe('foo/{01..25}/bar', {
+  expandRange(a, b) {
+    return `(${fill(a, b, { toRegex: true })})`;
+  }
+});
+
+console.log(regex);
+//=> /^(?:foo\/((?:0[1-9]|1[0-9]|2[0-5]))\/bar)$/
+
+console.log(regex.test('foo/00/bar'))  // false
+console.log(regex.test('foo/01/bar'))  // true
+console.log(regex.test('foo/10/bar')) // true
+console.log(regex.test('foo/22/bar')) // true
+console.log(regex.test('foo/25/bar')) // true
+console.log(regex.test('foo/26/bar')) // false
+```
+
+#### options.format
+
+**Type**: `function`
+
+**Default**: `undefined`
+
+Custom function for formatting strings before they're matched.
+
+**Example**
+
+```js
+// strip leading './' from strings
+const format = str => str.replace(/^\.\//, '');
+const isMatch = picomatch('foo/*.js', { format });
+console.log(isMatch('./foo/bar.js')); //=> true
+```
+
+#### options.onMatch
+
+```js
+const onMatch = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onMatch });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onIgnore
+
+```js
+const onIgnore = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onIgnore, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+#### options.onResult
+
+```js
+const onResult = ({ glob, regex, input, output }) => {
+  console.log({ glob, regex, input, output });
+};
+
+const isMatch = picomatch('*', { onResult, ignore: 'f*' });
+isMatch('foo');
+isMatch('bar');
+isMatch('baz');
+```
+
+<br>
+<br>
+
+## Globbing features
+
+* [Basic globbing](#basic-globbing) (Wildcard matching)
+* [Advanced globbing](#advanced-globbing) (extglobs, posix brackets, brace matching)
+
+### Basic globbing
+
+| **Character** | **Description** |
+| --- | --- |
+| `*` | Matches any character zero or more times, excluding path separators. Does _not match_ path separators or hidden files or directories ("dotfiles"), unless explicitly enabled by setting the `dot` option to `true`. |
+| `**` | Matches any character zero or more times, including path separators. Note that `**` will only match path separators (`/`, and `\\` with the `windows` option) when they are the only characters in a path segment. Thus, `foo**/bar` is equivalent to `foo*/bar`, and `foo/a**b/bar` is equivalent to `foo/a*b/bar`, and _more than two_ consecutive stars in a glob path segment are regarded as _a single star_. Thus, `foo/***/bar` is equivalent to `foo/*/bar`. |
+| `?` | Matches any character excluding path separators one time. Does _not match_ path separators or leading dots.  |
+| `[abc]` | Matches any characters inside the brackets. For example, `[abc]` would match the characters `a`, `b` or `c`, and nothing else. |
+
+#### Matching behavior vs. Bash
+
+Picomatch's matching features and expected results in unit tests are based on Bash's unit tests and the Bash 4.3 specification, with the following exceptions:
+
+* Bash will match `foo/bar/baz` with `*`. Picomatch only matches nested directories with `**`.
+* Bash greedily matches with negated extglobs. For example, Bash 4.3 says that `!(foo)*` should match `foo` and `foobar`, since the trailing `*` bracktracks to match the preceding pattern. This is very memory-inefficient, and IMHO, also incorrect. Picomatch would return `false` for both `foo` and `foobar`.
+
+<br>
+
+### Advanced globbing
+
+* [extglobs](#extglobs)
+* [POSIX brackets](#posix-brackets)
+* [Braces](#brace-expansion)
+
+#### Extglobs
+
+| **Pattern** | **Description** |
+| --- | --- |
+| `@(pattern)` | Match _only one_ consecutive occurrence of `pattern` |
+| `*(pattern)` | Match _zero or more_ consecutive occurrences of `pattern` |
+| `+(pattern)` | Match _one or more_ consecutive occurrences of `pattern` |
+| `?(pattern)` | Match _zero or **one**_ consecutive occurrences of `pattern` |
+| `!(pattern)` | Match _anything but_ `pattern` |
+
+**Examples**
+
+```js
+const pm = require('picomatch');
+
+// *(pattern) matches ZERO or more of "pattern"
+console.log(pm.isMatch('a', 'a*(z)')); // true
+console.log(pm.isMatch('az', 'a*(z)')); // true
+console.log(pm.isMatch('azzz', 'a*(z)')); // true
+
+// +(pattern) matches ONE or more of "pattern"
+console.log(pm.isMatch('a', 'a+(z)')); // false
+console.log(pm.isMatch('az', 'a+(z)')); // true
+console.log(pm.isMatch('azzz', 'a+(z)')); // true
+
+// supports multiple extglobs
+console.log(pm.isMatch('foo.bar', '!(foo).!(bar)')); // false
+
+// supports nested extglobs
+console.log(pm.isMatch('foo.bar', '!(!(foo)).!(!(bar))')); // true
+```
+
+#### POSIX brackets
+
+POSIX classes are disabled by default. Enable this feature by setting the `posix` option to true.
+
+**Enable POSIX bracket support**
+
+```js
+console.log(pm.makeRe('[[:word:]]+', { posix: true }));
+//=> /^(?:(?=.)[A-Za-z0-9_]+\/?)$/
+```
+
+**Supported POSIX classes**
+
+The following named POSIX bracket expressions are supported:
+
+* `[:alnum:]` - Alphanumeric characters, equ `[a-zA-Z0-9]`
+* `[:alpha:]` - Alphabetical characters, equivalent to `[a-zA-Z]`.
+* `[:ascii:]` - ASCII characters, equivalent to `[\\x00-\\x7F]`.
+* `[:blank:]` - Space and tab characters, equivalent to `[ \\t]`.
+* `[:cntrl:]` - Control characters, equivalent to `[\\x00-\\x1F\\x7F]`.
+* `[:digit:]` - Numerical digits, equivalent to `[0-9]`.
+* `[:graph:]` - Graph characters, equivalent to `[\\x21-\\x7E]`.
+* `[:lower:]` - Lowercase letters, equivalent to `[a-z]`.
+* `[:print:]` - Print characters, equivalent to `[\\x20-\\x7E ]`.
+* `[:punct:]` - Punctuation and symbols, equivalent to `[\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~]`.
+* `[:space:]` - Extended space characters, equivalent to `[ \\t\\r\\n\\v\\f]`.
+* `[:upper:]` - Uppercase letters, equivalent to `[A-Z]`.
+* `[:word:]` -  Word characters (letters, numbers and underscores), equivalent to `[A-Za-z0-9_]`.
+* `[:xdigit:]` - Hexadecimal digits, equivalent to `[A-Fa-f0-9]`.
+
+See the [Bash Reference Manual](https://www.gnu.org/software/bash/manual/html_node/Pattern-Matching.html) for more information.
+
+### Braces
+
+Picomatch does not do brace expansion. For [brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html) and advanced matching with braces, use [micromatch](https://github.com/micromatch/micromatch) instead. Picomatch has very basic support for braces.
+
+### Matching special characters as literals
+
+If you wish to match the following special characters in a filepath, and you want to use these characters in your glob pattern, they must be escaped with backslashes or quotes:
+
+**Special Characters**
+
+Some characters that are used for matching in regular expressions are also regarded as valid file path characters on some platforms.
+
+To match any of the following characters as literals: `$^*+?()[]
+
+Examples:
+
+```js
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+console.log(pm.makeRe('foo/bar \\(1\\)'));
+```
+
+<br>
+<br>
+
+## Library Comparisons
+
+The following table shows which features are supported by [minimatch](https://github.com/isaacs/minimatch), [micromatch](https://github.com/micromatch/micromatch), [picomatch](https://github.com/micromatch/picomatch), [nanomatch](https://github.com/micromatch/nanomatch), [extglob](https://github.com/micromatch/extglob), [braces](https://github.com/micromatch/braces), and [expand-brackets](https://github.com/micromatch/expand-brackets).
+
+| **Feature** | `minimatch` | `micromatch` | `picomatch` | `nanomatch` | `extglob` | `braces` | `expand-brackets` |
+| --- | --- | --- | --- | --- | --- | --- | --- |
+| Wildcard matching (`*?+`) | ✔ | ✔ | ✔ | ✔ | - | - | - |
+| Advancing globbing        | ✔ | ✔ | ✔ | - | - | - | - |
+| Brace _matching_          | ✔ | ✔ | ✔ | - | - | ✔ | - |
+| Brace _expansion_         | ✔ | ✔ | - | - | - | ✔ | - |
+| Extglobs                  | partial | ✔ | ✔ | - | ✔ | - | - |
+| Posix brackets            | - | ✔ | ✔ | - | - | - | ✔ |
+| Regular expression syntax | - | ✔ | ✔ | ✔ | ✔ | - | ✔ |
+| File system operations    | - | - | - | - | - | - | - |
+
+<br>
+<br>
+
+## Benchmarks
+
+Performance comparison of picomatch and minimatch.
+
+_(Pay special attention to the last three benchmarks. Minimatch freezes on long ranges.)_
+
+```
+# .makeRe star (*)
+  picomatch x 4,449,159 ops/sec ±0.24% (97 runs sampled)
+  minimatch x 632,772 ops/sec ±0.14% (98 runs sampled)
+
+# .makeRe star; dot=true (*)
+  picomatch x 3,500,079 ops/sec ±0.26% (99 runs sampled)
+  minimatch x 564,916 ops/sec ±0.23% (96 runs sampled)
+
+# .makeRe globstar (**)
+  picomatch x 3,261,000 ops/sec ±0.27% (98 runs sampled)
+  minimatch x 1,664,766 ops/sec ±0.20% (100 runs sampled)
+
+# .makeRe globstars (**/**/**)
+  picomatch x 3,284,469 ops/sec ±0.18% (97 runs sampled)
+  minimatch x 1,435,880 ops/sec ±0.34% (95 runs sampled)
+
+# .makeRe with leading star (*.txt)
+  picomatch x 3,100,197 ops/sec ±0.35% (99 runs sampled)
+  minimatch x 428,347 ops/sec ±0.42% (94 runs sampled)
+
+# .makeRe - basic braces ({a,b,c}*.txt)
+  picomatch x 443,578 ops/sec ±1.33% (89 runs sampled)
+  minimatch x 107,143 ops/sec ±0.35% (94 runs sampled)
+
+# .makeRe - short ranges ({a..z}*.txt)
+  picomatch x 415,484 ops/sec ±0.76% (96 runs sampled)
+  minimatch x 14,299 ops/sec ±0.26% (96 runs sampled)
+
+# .makeRe - medium ranges ({1..100000}*.txt)
+  picomatch x 395,020 ops/sec ±0.87% (89 runs sampled)
+  minimatch x 2 ops/sec ±4.59% (10 runs sampled)
+
+# .makeRe - long ranges ({1..10000000}*.txt)
+  picomatch x 400,036 ops/sec ±0.83% (90 runs sampled)
+  minimatch (FATAL ERROR: Ineffective mark-compacts near heap limit Allocation failed - JavaScript heap out of memory)
+```
+
+<br>
+<br>
+
+## Philosophies
+
+The goal of this library is to be blazing fast, without compromising on accuracy.
+
+**Accuracy**
+
+The number one of goal of this library is accuracy. However, it's not unusual for different glob implementations to have different rules for matching behavior, even with simple wildcard matching. It gets increasingly more complicated when combinations of different features are combined, like when extglobs are combined with globstars, braces, slashes, and so on: `!(**/{a,b,*/c})`.
+
+Thus, given that there is no canonical glob specification to use as a single source of truth when differences of opinion arise regarding behavior, sometimes we have to implement our best judgement and rely on feedback from users to make improvements.
+
+**Performance**
+
+Although this library performs well in benchmarks, and in most cases it's faster than other popular libraries we benchmarked against, we will always choose accuracy over performance. It's not helpful to anyone if our library is faster at returning the wrong answer.
+
+<br>
+<br>
+
+## About
+
+<details>
+<summary><strong>Contributing</strong></summary>
+
+Pull requests and stars are always welcome. For bugs and feature requests, [please create an issue](../../issues/new).
+
+Please read the [contributing guide](.github/contributing.md) for advice on opening issues, pull requests, and coding standards.
+
+</details>
+
+<details>
+<summary><strong>Running Tests</strong></summary>
+
+Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
+
+```sh
+npm install && npm test
+```
+
+</details>
+
+<details>
+<summary><strong>Building docs</strong></summary>
+
+_(This project's readme.md is generated by [verb](https://github.com/verbose/verb-generate-readme), please don't edit the readme directly. Any changes to the readme must be made in the [.verb.md](.verb.md) readme template.)_
+
+To generate the readme, run the following command:
+
+```sh
+npm install -g verbose/verb#dev verb-generate-readme && verb
+```
+
+</details>
+
+### Author
+
+**Jon Schlinkert**
+
+* [GitHub Profile](https://github.com/jonschlinkert)
+* [Twitter Profile](https://twitter.com/jonschlinkert)
+* [LinkedIn Profile](https://linkedin.com/in/jonschlinkert)
+
+### License
+
+Copyright © 2017-present, [Jon Schlinkert](https://github.com/jonschlinkert).
+Released under the [MIT License](LICENSE).

backend/node_modules/tinyglobby/node_modules/picomatch/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const pico = require('./lib/picomatch');
+const utils = require('./lib/utils');
+
+function picomatch(glob, options, returnState = false) {
+  // default to os.platform()
+  if (options && (options.windows === null || options.windows === undefined)) {
+    // don't mutate the original options object
+    options = { ...options, windows: utils.isWindows() };
+  }
+
+  return pico(glob, options, returnState);
+}
+
+Object.assign(picomatch, pico);
+module.exports = picomatch;

backend/node_modules/tinyglobby/node_modules/picomatch/lib/constants.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const WIN_SLASH = '\\\\/';
+const WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+
+/**
+ * Posix glob regex
+ */
+
+const DOT_LITERAL = '\\.';
+const PLUS_LITERAL = '\\+';
+const QMARK_LITERAL = '\\?';
+const SLASH_LITERAL = '\\/';
+const ONE_CHAR = '(?=.)';
+const QMARK = '[^/]';
+const END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+const START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+const DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+const NO_DOT = `(?!${DOT_LITERAL})`;
+const NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+const NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+const NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+const QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+const STAR = `${QMARK}*?`;
+const SEP = '/';
+
+const POSIX_CHARS = {
+  DOT_LITERAL,
+  PLUS_LITERAL,
+  QMARK_LITERAL,
+  SLASH_LITERAL,
+  ONE_CHAR,
+  QMARK,
+  END_ANCHOR,
+  DOTS_SLASH,
+  NO_DOT,
+  NO_DOTS,
+  NO_DOT_SLASH,
+  NO_DOTS_SLASH,
+  QMARK_NO_DOT,
+  STAR,
+  START_ANCHOR,
+  SEP
+};
+
+/**
+ * Windows glob regex
+ */
+
+const WINDOWS_CHARS = {
+  ...POSIX_CHARS,
+
+  SLASH_LITERAL: `[${WIN_SLASH}]`,
+  QMARK: WIN_NO_SLASH,
+  STAR: `${WIN_NO_SLASH}*?`,
+  DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+  NO_DOT: `(?!${DOT_LITERAL})`,
+  NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+  NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+  QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+  START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+  END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+  SEP: '\\'
+};
+
+/**
+ * POSIX Bracket Regex
+ */
+
+const POSIX_REGEX_SOURCE = {
+  alnum: 'a-zA-Z0-9',
+  alpha: 'a-zA-Z',
+  ascii: '\\x00-\\x7F',
+  blank: ' \\t',
+  cntrl: '\\x00-\\x1F\\x7F',
+  digit: '0-9',
+  graph: '\\x21-\\x7E',
+  lower: 'a-z',
+  print: '\\x20-\\x7E ',
+  punct: '\\-!"#$%&\'()\\*+,./:;<=>?@[\\]^_`{|}~',
+  space: ' \\t\\r\\n\\v\\f',
+  upper: 'A-Z',
+  word: 'A-Za-z0-9_',
+  xdigit: 'A-Fa-f0-9'
+};
+
+module.exports = {
+  MAX_LENGTH: 1024 * 64,
+  POSIX_REGEX_SOURCE,
+
+  // regular expressions
+  REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+  REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+  REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+  REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+  REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+  REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+
+  // Replace globs with equivalent patterns to reduce parsing time.
+  REPLACEMENTS: {
+    '***': '*',
+    '**/**': '**',
+    '**/**/**': '**'
+  },
+
+  // Digits
+  CHAR_0: 48, /* 0 */
+  CHAR_9: 57, /* 9 */
+
+  // Alphabet chars.
+  CHAR_UPPERCASE_A: 65, /* A */
+  CHAR_LOWERCASE_A: 97, /* a */
+  CHAR_UPPERCASE_Z: 90, /* Z */
+  CHAR_LOWERCASE_Z: 122, /* z */
+
+  CHAR_LEFT_PARENTHESES: 40, /* ( */
+  CHAR_RIGHT_PARENTHESES: 41, /* ) */
+
+  CHAR_ASTERISK: 42, /* * */
+
+  // Non-alphabetic chars.
+  CHAR_AMPERSAND: 38, /* & */
+  CHAR_AT: 64, /* @ */
+  CHAR_BACKWARD_SLASH: 92, /* \ */
+  CHAR_CARRIAGE_RETURN: 13, /* \r */
+  CHAR_CIRCUMFLEX_ACCENT: 94, /* ^ */
+  CHAR_COLON: 58, /* : */
+  CHAR_COMMA: 44, /* , */
+  CHAR_DOT: 46, /* . */
+  CHAR_DOUBLE_QUOTE: 34, /* " */
+  CHAR_EQUAL: 61, /* = */
+  CHAR_EXCLAMATION_MARK: 33, /* ! */
+  CHAR_FORM_FEED: 12, /* \f */
+  CHAR_FORWARD_SLASH: 47, /* / */
+  CHAR_GRAVE_ACCENT: 96, /* ` */
+  CHAR_HASH: 35, /* # */
+  CHAR_HYPHEN_MINUS: 45, /* - */
+  CHAR_LEFT_ANGLE_BRACKET: 60, /* < */
+  CHAR_LEFT_CURLY_BRACE: 123, /* { */
+  CHAR_LEFT_SQUARE_BRACKET: 91, /* [ */
+  CHAR_LINE_FEED: 10, /* \n */
+  CHAR_NO_BREAK_SPACE: 160, /* \u00A0 */
+  CHAR_PERCENT: 37, /* % */
+  CHAR_PLUS: 43, /* + */
+  CHAR_QUESTION_MARK: 63, /* ? */
+  CHAR_RIGHT_ANGLE_BRACKET: 62, /* > */
+  CHAR_RIGHT_CURLY_BRACE: 125, /* } */
+  CHAR_RIGHT_SQUARE_BRACKET: 93, /* ] */
+  CHAR_SEMICOLON: 59, /* ; */
+  CHAR_SINGLE_QUOTE: 39, /* ' */
+  CHAR_SPACE: 32, /*   */
+  CHAR_TAB: 9, /* \t */
+  CHAR_UNDERSCORE: 95, /* _ */
+  CHAR_VERTICAL_LINE: 124, /* | */
+  CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279, /* \uFEFF */
+
+  /**
+   * Create EXTGLOB_CHARS
+   */
+
+  extglobChars(chars) {
+    return {
+      '!': { type: 'negate', open: '(?:(?!(?:', close: `))${chars.STAR})` },
+      '?': { type: 'qmark', open: '(?:', close: ')?' },
+      '+': { type: 'plus', open: '(?:', close: ')+' },
+      '*': { type: 'star', open: '(?:', close: ')*' },
+      '@': { type: 'at', open: '(?:', close: ')' }
+    };
+  },
+
+  /**
+   * Create GLOB_CHARS
+   */
+
+  globChars(win32) {
+    return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+  }
+};

backend/node_modules/tinyglobby/node_modules/picomatch/lib/picomatch.js

@@ -0,0 +1,341 @@
+'use strict';
+
+const scan = require('./scan');
+const parse = require('./parse');
+const utils = require('./utils');
+const constants = require('./constants');
+const isObject = val => val && typeof val === 'object' && !Array.isArray(val);
+
+/**
+ * Creates a matcher function from one or more glob patterns. The
+ * returned function takes a string to match as its first argument,
+ * and returns true if the string is a match. The returned matcher
+ * function also takes a boolean as the second argument that, when true,
+ * returns an object with additional information.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch(glob[, options]);
+ *
+ * const isMatch = picomatch('*.!(*a)');
+ * console.log(isMatch('a.a')); //=> false
+ * console.log(isMatch('a.b')); //=> true
+ * ```
+ * @name picomatch
+ * @param {String|Array} `globs` One or more glob patterns.
+ * @param {Object=} `options`
+ * @return {Function=} Returns a matcher function.
+ * @api public
+ */
+
+const picomatch = (glob, options, returnState = false) => {
+  if (Array.isArray(glob)) {
+    const fns = glob.map(input => picomatch(input, options, returnState));
+    const arrayMatcher = str => {
+      for (const isMatch of fns) {
+        const state = isMatch(str);
+        if (state) return state;
+      }
+      return false;
+    };
+    return arrayMatcher;
+  }
+
+  const isState = isObject(glob) && glob.tokens && glob.input;
+
+  if (glob === '' || (typeof glob !== 'string' && !isState)) {
+    throw new TypeError('Expected pattern to be a non-empty string');
+  }
+
+  const opts = options || {};
+  const posix = opts.windows;
+  const regex = isState
+    ? picomatch.compileRe(glob, options)
+    : picomatch.makeRe(glob, options, false, true);
+
+  const state = regex.state;
+  delete regex.state;
+
+  let isIgnored = () => false;
+  if (opts.ignore) {
+    const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+    isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+  }
+
+  const matcher = (input, returnObject = false) => {
+    const { isMatch, match, output } = picomatch.test(input, regex, options, { glob, posix });
+    const result = { glob, state, regex, posix, input, output, match, isMatch };
+
+    if (typeof opts.onResult === 'function') {
+      opts.onResult(result);
+    }
+
+    if (isMatch === false) {
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (isIgnored(input)) {
+      if (typeof opts.onIgnore === 'function') {
+        opts.onIgnore(result);
+      }
+      result.isMatch = false;
+      return returnObject ? result : false;
+    }
+
+    if (typeof opts.onMatch === 'function') {
+      opts.onMatch(result);
+    }
+    return returnObject ? result : true;
+  };
+
+  if (returnState) {
+    matcher.state = state;
+  }
+
+  return matcher;
+};
+
+/**
+ * Test `input` with the given `regex`. This is used by the main
+ * `picomatch()` function to test the input string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.test(input, regex[, options]);
+ *
+ * console.log(picomatch.test('foo/bar', /^(?:([^/]*?)\/([^/]*?))$/));
+ * // { isMatch: true, match: [ 'foo/', 'foo', 'bar' ], output: 'foo/bar' }
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp} `regex`
+ * @return {Object} Returns an object with matching info.
+ * @api public
+ */
+
+picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+  if (typeof input !== 'string') {
+    throw new TypeError('Expected input to be a string');
+  }
+
+  if (input === '') {
+    return { isMatch: false, output: '' };
+  }
+
+  const opts = options || {};
+  const format = opts.format || (posix ? utils.toPosixSlashes : null);
+  let match = input === glob;
+  let output = (match && format) ? format(input) : input;
+
+  if (match === false) {
+    output = format ? format(input) : input;
+    match = output === glob;
+  }
+
+  if (match === false || opts.capture === true) {
+    if (opts.matchBase === true || opts.basename === true) {
+      match = picomatch.matchBase(input, regex, options, posix);
+    } else {
+      match = regex.exec(output);
+    }
+  }
+
+  return { isMatch: Boolean(match), match, output };
+};
+
+/**
+ * Match the basename of a filepath.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.matchBase(input, glob[, options]);
+ * console.log(picomatch.matchBase('foo/bar.js', '*.js'); // true
+ * ```
+ * @param {String} `input` String to test.
+ * @param {RegExp|String} `glob` Glob pattern or regex created by [.makeRe](#makeRe).
+ * @return {Boolean}
+ * @api public
+ */
+
+picomatch.matchBase = (input, glob, options) => {
+  const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+  return regex.test(utils.basename(input));
+};
+
+/**
+ * Returns true if **any** of the given glob `patterns` match the specified `string`.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.isMatch(string, patterns[, options]);
+ *
+ * console.log(picomatch.isMatch('a.a', ['b.*', '*.a'])); //=> true
+ * console.log(picomatch.isMatch('a.a', 'b.*')); //=> false
+ * ```
+ * @param {String|Array} str The string to test.
+ * @param {String|Array} patterns One or more glob patterns to use for matching.
+ * @param {Object} [options] See available [options](#options).
+ * @return {Boolean} Returns true if any patterns match `str`
+ * @api public
+ */
+
+picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+
+/**
+ * Parse a glob pattern to create the source string for a regular
+ * expression.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const result = picomatch.parse(pattern[, options]);
+ * ```
+ * @param {String} `pattern`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with useful properties and output to be used as a regex source string.
+ * @api public
+ */
+
+picomatch.parse = (pattern, options) => {
+  if (Array.isArray(pattern)) return pattern.map(p => picomatch.parse(p, options));
+  return parse(pattern, { ...options, fastpaths: false });
+};
+
+/**
+ * Scan a glob pattern to separate the pattern into segments.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.scan(input[, options]);
+ *
+ * const result = picomatch.scan('!./foo/*.js');
+ * console.log(result);
+ * { prefix: '!./',
+ *   input: '!./foo/*.js',
+ *   start: 3,
+ *   base: 'foo',
+ *   glob: '*.js',
+ *   isBrace: false,
+ *   isBracket: false,
+ *   isGlob: true,
+ *   isExtglob: false,
+ *   isGlobstar: false,
+ *   negated: true }
+ * ```
+ * @param {String} `input` Glob pattern to scan.
+ * @param {Object} `options`
+ * @return {Object} Returns an object with
+ * @api public
+ */
+
+picomatch.scan = (input, options) => scan(input, options);
+
+/**
+ * Compile a regular expression from the `state` object returned by the
+ * [parse()](#parse) method.
+ *
+ * @param {Object} `state`
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Intended for implementors, this argument allows you to return the raw output from the parser.
+ * @param {Boolean} `returnState` Adds the state to a `state` property on the returned regex. Useful for implementors and debugging.
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+  if (returnOutput === true) {
+    return state.output;
+  }
+
+  const opts = options || {};
+  const prepend = opts.contains ? '' : '^';
+  const append = opts.contains ? '' : '$';
+
+  let source = `${prepend}(?:${state.output})${append}`;
+  if (state && state.negated === true) {
+    source = `^(?!${source}).*$`;
+  }
+
+  const regex = picomatch.toRegex(source, options);
+  if (returnState === true) {
+    regex.state = state;
+  }
+
+  return regex;
+};
+
+/**
+ * Create a regular expression from a parsed glob pattern.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * const state = picomatch.parse('*.js');
+ * // picomatch.compileRe(state[, options]);
+ *
+ * console.log(picomatch.compileRe(state));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `state` The object returned from the `.parse` method.
+ * @param {Object} `options`
+ * @param {Boolean} `returnOutput` Implementors may use this argument to return the compiled output, instead of a regular expression. This is not exposed on the options to prevent end-users from mutating the result.
+ * @param {Boolean} `returnState` Implementors may use this argument to return the state from the parsed glob with the returned regular expression.
+ * @return {RegExp} Returns a regex created from the given pattern.
+ * @api public
+ */
+
+picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+  if (!input || typeof input !== 'string') {
+    throw new TypeError('Expected a non-empty string');
+  }
+
+  let parsed = { negated: false, fastpaths: true };
+
+  if (options.fastpaths !== false && (input[0] === '.' || input[0] === '*')) {
+    parsed.output = parse.fastpaths(input, options);
+  }
+
+  if (!parsed.output) {
+    parsed = parse(input, options);
+  }
+
+  return picomatch.compileRe(parsed, options, returnOutput, returnState);
+};
+
+/**
+ * Create a regular expression from the given regex source string.
+ *
+ * ```js
+ * const picomatch = require('picomatch');
+ * // picomatch.toRegex(source[, options]);
+ *
+ * const { output } = picomatch.parse('*.js');
+ * console.log(picomatch.toRegex(output));
+ * //=> /^(?:(?!\.)(?=.)[^/]*?\.js)$/
+ * ```
+ * @param {String} `source` Regular expression source string.
+ * @param {Object} `options`
+ * @return {RegExp}
+ * @api public
+ */
+
+picomatch.toRegex = (source, options) => {
+  try {
+    const opts = options || {};
+    return new RegExp(source, opts.flags || (opts.nocase ? 'i' : ''));
+  } catch (err) {
+    if (options && options.debug === true) throw err;
+    return /$^/;
+  }
+};
+
+/**
+ * Picomatch constants.
+ * @return {Object}
+ */
+
+picomatch.constants = constants;
+
+/**
+ * Expose "picomatch"
+ */
+
+module.exports = picomatch;

backend/node_modules/tinyglobby/node_modules/picomatch/lib/scan.js

@@ -0,0 +1,391 @@
+'use strict';
+
+const utils = require('./utils');
+const {
+  CHAR_ASTERISK,             /* * */
+  CHAR_AT,                   /* @ */
+  CHAR_BACKWARD_SLASH,       /* \ */
+  CHAR_COMMA,                /* , */
+  CHAR_DOT,                  /* . */
+  CHAR_EXCLAMATION_MARK,     /* ! */
+  CHAR_FORWARD_SLASH,        /* / */
+  CHAR_LEFT_CURLY_BRACE,     /* { */
+  CHAR_LEFT_PARENTHESES,     /* ( */
+  CHAR_LEFT_SQUARE_BRACKET,  /* [ */
+  CHAR_PLUS,                 /* + */
+  CHAR_QUESTION_MARK,        /* ? */
+  CHAR_RIGHT_CURLY_BRACE,    /* } */
+  CHAR_RIGHT_PARENTHESES,    /* ) */
+  CHAR_RIGHT_SQUARE_BRACKET  /* ] */
+} = require('./constants');
+
+const isPathSeparator = code => {
+  return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+};
+
+const depth = token => {
+  if (token.isPrefix !== true) {
+    token.depth = token.isGlobstar ? Infinity : 1;
+  }
+};
+
+/**
+ * Quickly scans a glob pattern and returns an object with a handful of
+ * useful properties, like `isGlob`, `path` (the leading non-glob, if it exists),
+ * `glob` (the actual pattern), `negated` (true if the path starts with `!` but not
+ * with `!(`) and `negatedExtglob` (true if the path starts with `!(`).
+ *
+ * ```js
+ * const pm = require('picomatch');
+ * console.log(pm.scan('foo/bar/*.js'));
+ * { isGlob: true, input: 'foo/bar/*.js', base: 'foo/bar', glob: '*.js' }
+ * ```
+ * @param {String} `str`
+ * @param {Object} `options`
+ * @return {Object} Returns an object with tokens and regex source string.
+ * @api public
+ */
+
+const scan = (input, options) => {
+  const opts = options || {};
+
+  const length = input.length - 1;
+  const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+  const slashes = [];
+  const tokens = [];
+  const parts = [];
+
+  let str = input;
+  let index = -1;
+  let start = 0;
+  let lastIndex = 0;
+  let isBrace = false;
+  let isBracket = false;
+  let isGlob = false;
+  let isExtglob = false;
+  let isGlobstar = false;
+  let braceEscaped = false;
+  let backslashes = false;
+  let negated = false;
+  let negatedExtglob = false;
+  let finished = false;
+  let braces = 0;
+  let prev;
+  let code;
+  let token = { value: '', depth: 0, isGlob: false };
+
+  const eos = () => index >= length;
+  const peek = () => str.charCodeAt(index + 1);
+  const advance = () => {
+    prev = code;
+    return str.charCodeAt(++index);
+  };
+
+  while (index < length) {
+    code = advance();
+    let next;
+
+    if (code === CHAR_BACKWARD_SLASH) {
+      backslashes = token.backslashes = true;
+      code = advance();
+
+      if (code === CHAR_LEFT_CURLY_BRACE) {
+        braceEscaped = true;
+      }
+      continue;
+    }
+
+    if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+      braces++;
+
+      while (eos() !== true && (code = advance())) {
+        if (code === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (code === CHAR_LEFT_CURLY_BRACE) {
+          braces++;
+          continue;
+        }
+
+        if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (braceEscaped !== true && code === CHAR_COMMA) {
+          isBrace = token.isBrace = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+
+          if (scanToEnd === true) {
+            continue;
+          }
+
+          break;
+        }
+
+        if (code === CHAR_RIGHT_CURLY_BRACE) {
+          braces--;
+
+          if (braces === 0) {
+            braceEscaped = false;
+            isBrace = token.isBrace = true;
+            finished = true;
+            break;
+          }
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (code === CHAR_FORWARD_SLASH) {
+      slashes.push(index);
+      tokens.push(token);
+      token = { value: '', depth: 0, isGlob: false };
+
+      if (finished === true) continue;
+      if (prev === CHAR_DOT && index === (start + 1)) {
+        start += 2;
+        continue;
+      }
+
+      lastIndex = index + 1;
+      continue;
+    }
+
+    if (opts.noext !== true) {
+      const isExtglobChar = code === CHAR_PLUS
+        || code === CHAR_AT
+        || code === CHAR_ASTERISK
+        || code === CHAR_QUESTION_MARK
+        || code === CHAR_EXCLAMATION_MARK;
+
+      if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+        isGlob = token.isGlob = true;
+        isExtglob = token.isExtglob = true;
+        finished = true;
+        if (code === CHAR_EXCLAMATION_MARK && index === start) {
+          negatedExtglob = true;
+        }
+
+        if (scanToEnd === true) {
+          while (eos() !== true && (code = advance())) {
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              continue;
+            }
+
+            if (code === CHAR_RIGHT_PARENTHESES) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              break;
+            }
+          }
+          continue;
+        }
+        break;
+      }
+    }
+
+    if (code === CHAR_ASTERISK) {
+      if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_QUESTION_MARK) {
+      isGlob = token.isGlob = true;
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+      break;
+    }
+
+    if (code === CHAR_LEFT_SQUARE_BRACKET) {
+      while (eos() !== true && (next = advance())) {
+        if (next === CHAR_BACKWARD_SLASH) {
+          backslashes = token.backslashes = true;
+          advance();
+          continue;
+        }
+
+        if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+          isBracket = token.isBracket = true;
+          isGlob = token.isGlob = true;
+          finished = true;
+          break;
+        }
+      }
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+
+    if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+      negated = token.negated = true;
+      start++;
+      continue;
+    }
+
+    if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+      isGlob = token.isGlob = true;
+
+      if (scanToEnd === true) {
+        while (eos() !== true && (code = advance())) {
+          if (code === CHAR_LEFT_PARENTHESES) {
+            backslashes = token.backslashes = true;
+            code = advance();
+            continue;
+          }
+
+          if (code === CHAR_RIGHT_PARENTHESES) {
+            finished = true;
+            break;
+          }
+        }
+        continue;
+      }
+      break;
+    }
+
+    if (isGlob === true) {
+      finished = true;
+
+      if (scanToEnd === true) {
+        continue;
+      }
+
+      break;
+    }
+  }
+
+  if (opts.noext === true) {
+    isExtglob = false;
+    isGlob = false;
+  }
+
+  let base = str;
+  let prefix = '';
+  let glob = '';
+
+  if (start > 0) {
+    prefix = str.slice(0, start);
+    str = str.slice(start);
+    lastIndex -= start;
+  }
+
+  if (base && isGlob === true && lastIndex > 0) {
+    base = str.slice(0, lastIndex);
+    glob = str.slice(lastIndex);
+  } else if (isGlob === true) {
+    base = '';
+    glob = str;
+  } else {
+    base = str;
+  }
+
+  if (base && base !== '' && base !== '/' && base !== str) {
+    if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+      base = base.slice(0, -1);
+    }
+  }
+
+  if (opts.unescape === true) {
+    if (glob) glob = utils.removeBackslashes(glob);
+
+    if (base && backslashes === true) {
+      base = utils.removeBackslashes(base);
+    }
+  }
+
+  const state = {
+    prefix,
+    input,
+    start,
+    base,
+    glob,
+    isBrace,
+    isBracket,
+    isGlob,
+    isExtglob,
+    isGlobstar,
+    negated,
+    negatedExtglob
+  };
+
+  if (opts.tokens === true) {
+    state.maxDepth = 0;
+    if (!isPathSeparator(code)) {
+      tokens.push(token);
+    }
+    state.tokens = tokens;
+  }
+
+  if (opts.parts === true || opts.tokens === true) {
+    let prevIndex;
+
+    for (let idx = 0; idx < slashes.length; idx++) {
+      const n = prevIndex ? prevIndex + 1 : start;
+      const i = slashes[idx];
+      const value = input.slice(n, i);
+      if (opts.tokens) {
+        if (idx === 0 && start !== 0) {
+          tokens[idx].isPrefix = true;
+          tokens[idx].value = prefix;
+        } else {
+          tokens[idx].value = value;
+        }
+        depth(tokens[idx]);
+        state.maxDepth += tokens[idx].depth;
+      }
+      if (idx !== 0 || value !== '') {
+        parts.push(value);
+      }
+      prevIndex = i;
+    }
+
+    if (prevIndex && prevIndex + 1 < input.length) {
+      const value = input.slice(prevIndex + 1);
+      parts.push(value);
+
+      if (opts.tokens) {
+        tokens[tokens.length - 1].value = value;
+        depth(tokens[tokens.length - 1]);
+        state.maxDepth += tokens[tokens.length - 1].depth;
+      }
+    }
+
+    state.slashes = slashes;
+    state.parts = parts;
+  }
+
+  return state;
+};
+
+module.exports = scan;

backend/node_modules/tinyglobby/node_modules/picomatch/lib/utils.js

@@ -0,0 +1,72 @@
+/*global navigator*/
+'use strict';
+
+const {
+  REGEX_BACKSLASH,
+  REGEX_REMOVE_BACKSLASH,
+  REGEX_SPECIAL_CHARS,
+  REGEX_SPECIAL_CHARS_GLOBAL
+} = require('./constants');
+
+exports.isObject = val => val !== null && typeof val === 'object' && !Array.isArray(val);
+exports.hasRegexChars = str => REGEX_SPECIAL_CHARS.test(str);
+exports.isRegexChar = str => str.length === 1 && exports.hasRegexChars(str);
+exports.escapeRegex = str => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, '\\$1');
+exports.toPosixSlashes = str => str.replace(REGEX_BACKSLASH, '/');
+
+exports.isWindows = () => {
+  if (typeof navigator !== 'undefined' && navigator.platform) {
+    const platform = navigator.platform.toLowerCase();
+    return platform === 'win32' || platform === 'windows';
+  }
+
+  if (typeof process !== 'undefined' && process.platform) {
+    return process.platform === 'win32';
+  }
+
+  return false;
+};
+
+exports.removeBackslashes = str => {
+  return str.replace(REGEX_REMOVE_BACKSLASH, match => {
+    return match === '\\' ? '' : match;
+  });
+};
+
+exports.escapeLast = (input, char, lastIdx) => {
+  const idx = input.lastIndexOf(char, lastIdx);
+  if (idx === -1) return input;
+  if (input[idx - 1] === '\\') return exports.escapeLast(input, char, idx - 1);
+  return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+};
+
+exports.removePrefix = (input, state = {}) => {
+  let output = input;
+  if (output.startsWith('./')) {
+    output = output.slice(2);
+    state.prefix = './';
+  }
+  return output;
+};
+
+exports.wrapOutput = (input, state = {}, options = {}) => {
+  const prepend = options.contains ? '' : '^';
+  const append = options.contains ? '' : '$';
+
+  let output = `${prepend}(?:${input})${append}`;
+  if (state.negated === true) {
+    output = `(?:^(?!${output}).*$)`;
+  }
+  return output;
+};
+
+exports.basename = (path, { windows } = {}) => {
+  const segs = path.split(windows ? /[\\/]/ : '/');
+  const last = segs[segs.length - 1];
+
+  if (last === '') {
+    return segs[segs.length - 2];
+  }
+
+  return last;
+};

backend/node_modules/tinyglobby/node_modules/picomatch/package.json

@@ -0,0 +1,83 @@
+{
+  "name": "picomatch",
+  "description": "Blazing fast and accurate glob matcher written in JavaScript, with no dependencies and full support for standard and extended Bash glob features, including braces, extglobs, POSIX brackets, and regular expressions.",
+  "version": "4.0.2",
+  "homepage": "https://github.com/micromatch/picomatch",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "funding": "https://github.com/sponsors/jonschlinkert",
+  "repository": "micromatch/picomatch",
+  "bugs": {
+    "url": "https://github.com/micromatch/picomatch/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js",
+    "posix.js",
+    "lib"
+  ],
+  "sideEffects": false,
+  "main": "index.js",
+  "engines": {
+    "node": ">=12"
+  },
+  "scripts": {
+    "lint": "eslint --cache --cache-location node_modules/.cache/.eslintcache --report-unused-disable-directives --ignore-path .gitignore .",
+    "mocha": "mocha --reporter dot",
+    "test": "npm run lint && npm run mocha",
+    "test:ci": "npm run test:cover",
+    "test:cover": "nyc npm run mocha"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.0",
+    "fill-range": "^7.0.1",
+    "gulp-format-md": "^2.0.0",
+    "mocha": "^10.4.0",
+    "nyc": "^15.1.0",
+    "time-require": "github:jonschlinkert/time-require"
+  },
+  "keywords": [
+    "glob",
+    "match",
+    "picomatch"
+  ],
+  "nyc": {
+    "reporter": [
+      "html",
+      "lcov",
+      "text-summary"
+    ]
+  },
+  "verb": {
+    "toc": {
+      "render": true,
+      "method": "preWrite",
+      "maxdepth": 3
+    },
+    "layout": "empty",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "lint": {
+      "reflinks": true
+    },
+    "related": {
+      "list": [
+        "braces",
+        "micromatch"
+      ]
+    },
+    "reflinks": [
+      "braces",
+      "expand-brackets",
+      "extglob",
+      "fill-range",
+      "micromatch",
+      "minimatch",
+      "nanomatch",
+      "picomatch"
+    ]
+  }
+}

backend/node_modules/tinyglobby/node_modules/picomatch/posix.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./lib/picomatch');

backend/node_modules/tinyglobby/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "tinyglobby",
+  "version": "0.2.14",
+  "description": "A fast and minimal alternative to globby and fast-glob",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "import": "./dist/index.mjs",
+    "require": "./dist/index.js"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "author": "Superchupu",
+  "license": "MIT",
+  "keywords": [
+    "glob",
+    "patterns",
+    "fast",
+    "implementation"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/SuperchupuDev/tinyglobby.git"
+  },
+  "bugs": {
+    "url": "https://github.com/SuperchupuDev/tinyglobby/issues"
+  },
+  "homepage": "https://github.com/SuperchupuDev/tinyglobby#readme",
+  "funding": {
+    "url": "https://github.com/sponsors/SuperchupuDev"
+  },
+  "dependencies": {
+    "fdir": "^6.4.4",
+    "picomatch": "^4.0.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.15.21",
+    "@types/picomatch": "^4.0.0",
+    "fs-fixture": "^2.7.1",
+    "tsdown": "^0.12.3",
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "biome check",
+    "format": "biome format --write",
+    "lint": "biome lint",
+    "lint:fix": "biome lint --fix --unsafe",
+    "test": "node --experimental-transform-types --test",
+    "test:coverage": "node --experimental-transform-types --test --experimental-test-coverage",
+    "test:only": "node --experimental-transform-types --test --test-only",
+    "typecheck": "tsc --noEmit"
+  }
+}