kly 0.0.1

package/dist/enrich-BHaZ2daX.mjs

@@ -0,0 +1,3000 @@
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+import Database from "better-sqlite3";
+import { globby } from "globby";
+import { execSync } from "node:child_process";
+import Parser from "tree-sitter";
+import Swift from "tree-sitter-swift";
+import TypeScript from "tree-sitter-typescript";
+import { complete, getModel } from "@mariozechner/pi-ai";
+import pLimit from "p-limit";
+import { renderMermaidASCII, renderMermaidSVG } from "beautiful-mermaid";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/config.ts
+const KLY_DIR = ".kly";
+const CONFIG_FILE = "config.yaml";
+const DB_DIR = "db";
+const STATE_FILE = "state.yaml";
+const DEFAULT_CONFIG = {
+	llm: {
+		provider: "openrouter",
+		model: "anthropic/claude-haiku-4.5",
+		apiKey: ""
+	},
+	include: [
+		"**/*.ts",
+		"**/*.tsx",
+		"**/*.js",
+		"**/*.jsx",
+		"**/*.swift"
+	],
+	exclude: [
+		"**/node_modules/**",
+		"**/dist/**",
+		"**/build/**",
+		"**/.git/**",
+		"**/.kly/**",
+		"**/vendor/**",
+		"**/*.d.ts",
+		"**/*.test.*",
+		"**/*.spec.*",
+		"**/__tests__/**"
+	]
+};
+function getKlyDir(root) {
+	return path.join(root, KLY_DIR);
+}
+function getConfigPath(root) {
+	return path.join(getKlyDir(root), CONFIG_FILE);
+}
+function getDbDir(root) {
+	return path.join(getKlyDir(root), DB_DIR);
+}
+function getDbPath(root, dbName) {
+	return path.join(getDbDir(root), `${dbName}.db`);
+}
+function getStatePath(root) {
+	return path.join(getKlyDir(root), STATE_FILE);
+}
+function isInitialized(root) {
+	return fs.existsSync(getKlyDir(root));
+}
+function initKlyDir(root, config) {
+	const klyDir = getKlyDir(root);
+	if (!fs.existsSync(klyDir)) fs.mkdirSync(klyDir, { recursive: true });
+	const dbDir = getDbDir(root);
+	if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+	const configToWrite = config || DEFAULT_CONFIG;
+	fs.writeFileSync(getConfigPath(root), stringify(configToWrite), "utf-8");
+}
+function loadConfig(root) {
+	const configPath = getConfigPath(root);
+	if (!fs.existsSync(configPath)) return DEFAULT_CONFIG;
+	const parsed = parse(fs.readFileSync(configPath, "utf-8"));
+	return {
+		...DEFAULT_CONFIG,
+		...parsed,
+		llm: {
+			...DEFAULT_CONFIG.llm,
+			...parsed.llm
+		}
+	};
+}
+function hashConfig(config) {
+	const significant = JSON.stringify({
+		include: config.include,
+		exclude: config.exclude
+	});
+	return createHash("sha256").update(significant).digest("hex");
+}
+//#endregion
+//#region src/database.ts
+var IndexDatabase = class {
+	db;
+	constructor(dbPath) {
+		this.db = new Database(dbPath);
+		this.db.pragma("journal_mode = WAL");
+		this.db.pragma("foreign_keys = ON");
+		this.init();
+	}
+	init() {
+		this.db.exec(`
+      CREATE TABLE IF NOT EXISTS files (
+        path TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        description TEXT NOT NULL DEFAULT '',
+        language TEXT NOT NULL,
+        imports TEXT NOT NULL DEFAULT '[]',
+        exports TEXT NOT NULL DEFAULT '[]',
+        symbols TEXT NOT NULL DEFAULT '[]',
+        summary TEXT NOT NULL DEFAULT '',
+        hash TEXT NOT NULL,
+        indexed_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS dependencies (
+        from_path TEXT NOT NULL,
+        to_path TEXT NOT NULL,
+        PRIMARY KEY (from_path, to_path)
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_deps_to ON dependencies(to_path);
+    `);
+		try {
+			this.db.exec(`
+        CREATE VIRTUAL TABLE files_fts USING fts5(
+          path, name, description, summary, symbols_text,
+          content=files,
+          content_rowid=rowid
+        );
+      `);
+		} catch {}
+		this.db.exec(`
+      CREATE TRIGGER IF NOT EXISTS files_ai AFTER INSERT ON files BEGIN
+        INSERT INTO files_fts(rowid, path, name, description, summary, symbols_text)
+        VALUES (new.rowid, new.path, new.name, new.description, new.summary, '');
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS files_ad AFTER DELETE ON files BEGIN
+        INSERT INTO files_fts(files_fts, rowid, path, name, description, summary, symbols_text)
+        VALUES ('delete', old.rowid, old.path, old.name, old.description, old.summary, '');
+      END;
+
+      CREATE TRIGGER IF NOT EXISTS files_au AFTER UPDATE ON files BEGIN
+        INSERT INTO files_fts(files_fts, rowid, path, name, description, summary, symbols_text)
+        VALUES ('delete', old.rowid, old.path, old.name, old.description, old.summary, '');
+        INSERT INTO files_fts(rowid, path, name, description, summary, symbols_text)
+        VALUES (new.rowid, new.path, new.name, new.description, new.summary, '');
+      END;
+    `);
+	}
+	getFile(filePath) {
+		const row = this.db.prepare("SELECT * FROM files WHERE path = ?").get(filePath);
+		return row ? rowToFileIndex(row) : void 0;
+	}
+	upsertFile(fileIndex) {
+		this.db.prepare(`
+      INSERT INTO files (path, name, description, language, imports, exports, symbols, summary, hash, indexed_at)
+      VALUES (@path, @name, @description, @language, @imports, @exports, @symbols, @summary, @hash, @indexed_at)
+      ON CONFLICT(path) DO UPDATE SET
+        name = @name,
+        description = @description,
+        language = @language,
+        imports = @imports,
+        exports = @exports,
+        symbols = @symbols,
+        summary = @summary,
+        hash = @hash,
+        indexed_at = @indexed_at
+    `).run(fileIndexToRow(fileIndex));
+		this.updateFtsSymbolsText(fileIndex);
+	}
+	upsertFiles(fileIndexes) {
+		const stmt = this.db.prepare(`
+      INSERT INTO files (path, name, description, language, imports, exports, symbols, summary, hash, indexed_at)
+      VALUES (@path, @name, @description, @language, @imports, @exports, @symbols, @summary, @hash, @indexed_at)
+      ON CONFLICT(path) DO UPDATE SET
+        name = @name,
+        description = @description,
+        language = @language,
+        imports = @imports,
+        exports = @exports,
+        symbols = @symbols,
+        summary = @summary,
+        hash = @hash,
+        indexed_at = @indexed_at
+    `);
+		this.db.transaction((files) => {
+			for (const file of files) {
+				stmt.run(fileIndexToRow(file));
+				this.updateFtsSymbolsText(file);
+			}
+		})(fileIndexes);
+	}
+	removeFile(filePath) {
+		this.db.prepare("DELETE FROM files WHERE path = ?").run(filePath);
+	}
+	removeFiles(paths) {
+		const stmt = this.db.prepare("DELETE FROM files WHERE path = ?");
+		this.db.transaction((pathList) => {
+			for (const p of pathList) stmt.run(p);
+		})(paths);
+	}
+	searchFiles(query, limit = 20) {
+		const ftsQuery = query.split(/\s+/).filter(Boolean).map((term) => `"${term.replace(/"/g, "\"\"")}"`).join(" OR ");
+		if (!ftsQuery) return [];
+		return this.db.prepare(`
+      SELECT f.*, bm25(files_fts) as rank
+      FROM files_fts fts
+      JOIN files f ON f.rowid = fts.rowid
+      WHERE files_fts MATCH ?
+      ORDER BY rank
+      LIMIT ?
+    `).all(ftsQuery, limit).map((row) => ({
+			file: rowToFileIndex(row),
+			score: -row.rank
+		}));
+	}
+	getAllFiles() {
+		return this.db.prepare("SELECT * FROM files ORDER BY path").all().map(rowToFileIndex);
+	}
+	getFileCount() {
+		return this.db.prepare("SELECT COUNT(*) as count FROM files").get().count;
+	}
+	getLanguageStats() {
+		const rows = this.db.prepare("SELECT language, COUNT(*) as count FROM files GROUP BY language").all();
+		const stats = {};
+		for (const row of rows) stats[row.language] = row.count;
+		return stats;
+	}
+	getMetadata(key) {
+		return this.db.prepare("SELECT value FROM metadata WHERE key = ?").get(key)?.value;
+	}
+	setMetadata(key, value) {
+		this.db.prepare(`INSERT INTO metadata (key, value) VALUES (?, ?)
+       ON CONFLICT(key) DO UPDATE SET value = ?`).run(key, value, value);
+	}
+	upsertDependencies(fromPath, toPaths) {
+		this.db.prepare("DELETE FROM dependencies WHERE from_path = ?").run(fromPath);
+		const stmt = this.db.prepare("INSERT OR IGNORE INTO dependencies (from_path, to_path) VALUES (?, ?)");
+		for (const to of toPaths) stmt.run(fromPath, to);
+	}
+	upsertBatchDependencies(entries) {
+		const del = this.db.prepare("DELETE FROM dependencies WHERE from_path = ?");
+		const ins = this.db.prepare("INSERT OR IGNORE INTO dependencies (from_path, to_path) VALUES (?, ?)");
+		this.db.transaction((items) => {
+			for (const { fromPath, toPaths } of items) {
+				del.run(fromPath);
+				for (const to of toPaths) ins.run(fromPath, to);
+			}
+		})(entries);
+	}
+	removeDependencies(fromPath) {
+		this.db.prepare("DELETE FROM dependencies WHERE from_path = ?").run(fromPath);
+	}
+	removeDependenciesBatch(fromPaths) {
+		const stmt = this.db.prepare("DELETE FROM dependencies WHERE from_path = ?");
+		this.db.transaction((paths) => {
+			for (const p of paths) stmt.run(p);
+		})(fromPaths);
+	}
+	getDependencies(filePath) {
+		return this.db.prepare("SELECT to_path FROM dependencies WHERE from_path = ? ORDER BY to_path").all(filePath).map((r) => r.to_path);
+	}
+	getDependents(filePath) {
+		return this.db.prepare("SELECT from_path FROM dependencies WHERE to_path = ? ORDER BY from_path").all(filePath).map((r) => r.from_path);
+	}
+	removeAllDependencies() {
+		this.db.exec("DELETE FROM dependencies");
+	}
+	close() {
+		this.db.close();
+	}
+	updateFtsSymbolsText(fileIndex) {
+		const symbolsText = fileIndex.symbols.map((s) => `${s.name} ${s.description}`).join(" ");
+		const row = this.db.prepare("SELECT rowid FROM files WHERE path = ?").get(fileIndex.path);
+		this.db.prepare(`INSERT INTO files_fts(files_fts, rowid, path, name, description, summary, symbols_text)
+         VALUES ('delete', ?, ?, ?, ?, ?, '')`).run(row.rowid, fileIndex.path, fileIndex.name, fileIndex.description, fileIndex.summary);
+		this.db.prepare(`INSERT INTO files_fts(rowid, path, name, description, summary, symbols_text)
+         VALUES (?, ?, ?, ?, ?, ?)`).run(row.rowid, fileIndex.path, fileIndex.name, fileIndex.description, fileIndex.summary, symbolsText);
+	}
+};
+function rowToFileIndex(row) {
+	return {
+		path: row.path,
+		name: row.name,
+		description: row.description,
+		language: row.language,
+		imports: JSON.parse(row.imports),
+		exports: JSON.parse(row.exports),
+		symbols: JSON.parse(row.symbols),
+		summary: row.summary,
+		hash: row.hash,
+		indexedAt: row.indexed_at
+	};
+}
+function fileIndexToRow(fileIndex) {
+	return {
+		path: fileIndex.path,
+		name: fileIndex.name,
+		description: fileIndex.description,
+		language: fileIndex.language,
+		imports: JSON.stringify(fileIndex.imports),
+		exports: JSON.stringify(fileIndex.exports),
+		symbols: JSON.stringify(fileIndex.symbols),
+		summary: fileIndex.summary,
+		hash: fileIndex.hash,
+		indexed_at: fileIndex.indexedAt
+	};
+}
+//#endregion
+//#region src/scanner.ts
+async function scanFiles(root, config) {
+	return (await globby(config.include, {
+		cwd: root,
+		ignore: config.exclude,
+		gitignore: true,
+		absolute: false
+	})).sort();
+}
+//#endregion
+//#region src/hasher.ts
+function hashFile(root, filePath) {
+	const fullPath = path.join(root, filePath);
+	const content = fs.readFileSync(fullPath, "utf-8");
+	return createHash("sha256").update(content).digest("hex");
+}
+function hasChanged(oldHash, newHash) {
+	return oldHash !== newHash;
+}
+//#endregion
+//#region src/git.ts
+function exec(root, cmd) {
+	return execSync(cmd, {
+		cwd: root,
+		encoding: "utf-8",
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	}).trim();
+}
+function isGitRepo(root) {
+	try {
+		exec(root, "git rev-parse --is-inside-work-tree");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getCurrentBranch(root) {
+	try {
+		return exec(root, "git symbolic-ref --short HEAD");
+	} catch {
+		return null;
+	}
+}
+function getCurrentCommit(root) {
+	return exec(root, "git rev-parse HEAD");
+}
+function getChangedFiles(root, from, to) {
+	const output = exec(root, `git diff --name-status ${from} ${to || "HEAD"}`);
+	const diff = {
+		added: [],
+		modified: [],
+		deleted: [],
+		renamed: []
+	};
+	if (!output) return diff;
+	for (const line of output.split("\n")) {
+		const parts = line.split("	");
+		const status = parts[0];
+		const filePath = parts[1];
+		switch (status[0]) {
+			case "A":
+				diff.added.push(filePath);
+				break;
+			case "M":
+				diff.modified.push(filePath);
+				break;
+			case "D":
+				diff.deleted.push(filePath);
+				break;
+			case "R":
+				diff.renamed.push({
+					from: filePath,
+					to: parts[2]
+				});
+				break;
+		}
+	}
+	return diff;
+}
+function isAncestor(root, ancestor, descendant) {
+	try {
+		execSync(`git merge-base --is-ancestor ${ancestor} ${descendant}`, {
+			cwd: root,
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getMergeBase(root, a, b) {
+	try {
+		return exec(root, `git merge-base ${a} ${b}`);
+	} catch {
+		return null;
+	}
+}
+function getFileHistory(root, filePath, limit = 5) {
+	let output;
+	try {
+		output = exec(root, `git log --follow -n ${limit} --format="%H|%an|%ae|%at|%s" -- "${filePath}"`);
+	} catch {
+		return [];
+	}
+	if (!output) return [];
+	return output.split("\n").filter(Boolean).map((line) => {
+		const [hash, author, email, date, ...msgParts] = line.split("|");
+		return {
+			hash,
+			author,
+			email,
+			date: parseInt(date, 10),
+			message: msgParts.join("|")
+		};
+	});
+}
+function branchToDbName(branch, commitHash) {
+	if (branch === null) return `_detached--${commitHash ? commitHash.slice(0, 8) : "unknown"}`;
+	return branch.replace(/\//g, "--");
+}
+//#endregion
+//#region src/store.ts
+const STATE_VERSION = 2;
+function openDatabase(root, dbName) {
+	const name = dbName || resolveDbName(root);
+	const dbDir = getDbDir(root);
+	if (!fs.existsSync(dbDir)) fs.mkdirSync(dbDir, { recursive: true });
+	return new IndexDatabase(getDbPath(root, name));
+}
+function resolveDbName(root) {
+	if (!isGitRepo(root)) return "default";
+	const branch = getCurrentBranch(root);
+	return branchToDbName(branch, branch === null ? getCurrentCommit(root) : void 0);
+}
+function copyDatabase(root, fromName, toName) {
+	const fromPath = getDbPath(root, fromName);
+	const toPath = getDbPath(root, toName);
+	if (fs.existsSync(fromPath)) fs.copyFileSync(fromPath, toPath);
+}
+function loadState(root) {
+	const statePath = getStatePath(root);
+	if (!fs.existsSync(statePath)) return {
+		version: STATE_VERSION,
+		configHash: "",
+		branches: {}
+	};
+	return parse(fs.readFileSync(statePath, "utf-8"));
+}
+function saveState(root, state) {
+	const statePath = getStatePath(root);
+	fs.writeFileSync(statePath, stringify(state), "utf-8");
+}
+function getBranchState(state, dbName) {
+	return state.branches[dbName];
+}
+function setBranchState(state, dbName, branchState) {
+	state.branches[dbName] = branchState;
+}
+function getFileFromDb(root, filePath) {
+	const db = openDatabase(root);
+	try {
+		return db.getFile(filePath);
+	} finally {
+		db.close();
+	}
+}
+function getAllFilesFromDb(root) {
+	const db = openDatabase(root);
+	try {
+		return db.getAllFiles();
+	} finally {
+		db.close();
+	}
+}
+function listBranchDbs(root) {
+	const dbDir = getDbDir(root);
+	if (!fs.existsSync(dbDir)) return [];
+	return fs.readdirSync(dbDir).filter((f) => f.endsWith(".db")).map((f) => f.replace(/\.db$/, ""));
+}
+function removeBranchDb(root, dbName) {
+	const dbPath = getDbPath(root, dbName);
+	if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath);
+	for (const ext of ["-wal", "-shm"]) {
+		const auxPath = dbPath + ext;
+		if (fs.existsSync(auxPath)) fs.unlinkSync(auxPath);
+	}
+}
+//#endregion
+//#region node_modules/picomatch/lib/constants.js
+var require_constants = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$3 = __require("path");
+	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 POSIX_CHARS = {
+		DOT_LITERAL,
+		PLUS_LITERAL,
+		QMARK_LITERAL,
+		SLASH_LITERAL,
+		ONE_CHAR,
+		QMARK,
+		END_ANCHOR,
+		DOTS_SLASH,
+		NO_DOT: `(?!${DOT_LITERAL})`,
+		NO_DOTS: `(?!${START_ANCHOR}${DOTS_SLASH})`,
+		NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`,
+		NO_DOTS_SLASH: `(?!${DOTS_SLASH})`,
+		QMARK_NO_DOT: `[^.${SLASH_LITERAL}]`,
+		STAR: `${QMARK}*?`,
+		START_ANCHOR
+	};
+	/**
+	* 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}]|$)`
+	};
+	module.exports = {
+		MAX_LENGTH: 1024 * 64,
+		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"
+		},
+		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,
+		REPLACEMENTS: {
+			"***": "*",
+			"**/**": "**",
+			"**/**/**": "**"
+		},
+		CHAR_0: 48,
+		CHAR_9: 57,
+		CHAR_UPPERCASE_A: 65,
+		CHAR_LOWERCASE_A: 97,
+		CHAR_UPPERCASE_Z: 90,
+		CHAR_LOWERCASE_Z: 122,
+		CHAR_LEFT_PARENTHESES: 40,
+		CHAR_RIGHT_PARENTHESES: 41,
+		CHAR_ASTERISK: 42,
+		CHAR_AMPERSAND: 38,
+		CHAR_AT: 64,
+		CHAR_BACKWARD_SLASH: 92,
+		CHAR_CARRIAGE_RETURN: 13,
+		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,
+		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,
+		CHAR_NO_BREAK_SPACE: 160,
+		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,
+		CHAR_UNDERSCORE: 95,
+		CHAR_VERTICAL_LINE: 124,
+		CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+		SEP: path$3.sep,
+		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: ")"
+				}
+			};
+		},
+		globChars(win32) {
+			return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+		}
+	};
+}));
+//#endregion
+//#region node_modules/picomatch/lib/utils.js
+var require_utils = /* @__PURE__ */ __commonJSMin(((exports) => {
+	const path$2 = __require("path");
+	const win32 = process.platform === "win32";
+	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.removeBackslashes = (str) => {
+		return str.replace(REGEX_REMOVE_BACKSLASH, (match) => {
+			return match === "\\" ? "" : match;
+		});
+	};
+	exports.supportsLookbehinds = () => {
+		const segs = process.version.slice(1).split(".").map(Number);
+		if (segs.length === 3 && segs[0] >= 9 || segs[0] === 8 && segs[1] >= 10) return true;
+		return false;
+	};
+	exports.isWindows = (options) => {
+		if (options && typeof options.windows === "boolean") return options.windows;
+		return win32 === true || path$2.sep === "\\";
+	};
+	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 = {}) => {
+		let output = `${options.contains ? "" : "^"}(?:${input})${options.contains ? "" : "$"}`;
+		if (state.negated === true) output = `(?:^(?!${output}).*$)`;
+		return output;
+	};
+}));
+//#endregion
+//#region node_modules/picomatch/lib/scan.js
+var require_scan = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	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) {
+				if ((code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK) === 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;
+}));
+//#endregion
+//#region node_modules/picomatch/lib/parse.js
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const constants = require_constants();
+	const utils = require_utils();
+	/**
+	* Constants
+	*/
+	const { MAX_LENGTH, POSIX_REGEX_SOURCE, REGEX_NON_SPECIAL_CHARS, REGEX_SPECIAL_CHARS_BACKREF, REPLACEMENTS } = constants;
+	/**
+	* Helpers
+	*/
+	const expandRange = (args, options) => {
+		if (typeof options.expandRange === "function") return options.expandRange(...args, options);
+		args.sort();
+		const value = `[${args.join("-")}]`;
+		try {
+			new RegExp(value);
+		} catch (ex) {
+			return args.map((v) => utils.escapeRegex(v)).join("..");
+		}
+		return value;
+	};
+	/**
+	* Create the message for a syntax error
+	*/
+	const syntaxError = (type, char) => {
+		return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+	};
+	/**
+	* Parse the given input string.
+	* @param {String} input
+	* @param {Object} options
+	* @return {Object}
+	*/
+	const parse = (input, options) => {
+		if (typeof input !== "string") throw new TypeError("Expected a string");
+		input = REPLACEMENTS[input] || input;
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		let len = input.length;
+		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		const bos = {
+			type: "bos",
+			value: "",
+			output: opts.prepend || ""
+		};
+		const tokens = [bos];
+		const capture = opts.capture ? "" : "?:";
+		const win32 = utils.isWindows(options);
+		const PLATFORM_CHARS = constants.globChars(win32);
+		const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+		const { DOT_LITERAL, PLUS_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOT_SLASH, NO_DOTS_SLASH, QMARK, QMARK_NO_DOT, STAR, START_ANCHOR } = PLATFORM_CHARS;
+		const globstar = (opts) => {
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		};
+		const nodot = opts.dot ? "" : NO_DOT;
+		const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+		let star = opts.bash === true ? globstar(opts) : STAR;
+		if (opts.capture) star = `(${star})`;
+		if (typeof opts.noext === "boolean") opts.noextglob = opts.noext;
+		const state = {
+			input,
+			index: -1,
+			start: 0,
+			dot: opts.dot === true,
+			consumed: "",
+			output: "",
+			prefix: "",
+			backtrack: false,
+			negated: false,
+			brackets: 0,
+			braces: 0,
+			parens: 0,
+			quotes: 0,
+			globstar: false,
+			tokens
+		};
+		input = utils.removePrefix(input, state);
+		len = input.length;
+		const extglobs = [];
+		const braces = [];
+		const stack = [];
+		let prev = bos;
+		let value;
+		/**
+		* Tokenizing helpers
+		*/
+		const eos = () => state.index === len - 1;
+		const peek = state.peek = (n = 1) => input[state.index + n];
+		const advance = state.advance = () => input[++state.index] || "";
+		const remaining = () => input.slice(state.index + 1);
+		const consume = (value = "", num = 0) => {
+			state.consumed += value;
+			state.index += num;
+		};
+		const append = (token) => {
+			state.output += token.output != null ? token.output : token.value;
+			consume(token.value);
+		};
+		const negate = () => {
+			let count = 1;
+			while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+				advance();
+				state.start++;
+				count++;
+			}
+			if (count % 2 === 0) return false;
+			state.negated = true;
+			state.start++;
+			return true;
+		};
+		const increment = (type) => {
+			state[type]++;
+			stack.push(type);
+		};
+		const decrement = (type) => {
+			state[type]--;
+			stack.pop();
+		};
+		/**
+		* Push tokens onto the tokens array. This helper speeds up
+		* tokenizing by 1) helping us avoid backtracking as much as possible,
+		* and 2) helping us avoid creating extra tokens when consecutive
+		* characters are plain text. This improves performance and simplifies
+		* lookbehinds.
+		*/
+		const push = (tok) => {
+			if (prev.type === "globstar") {
+				const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+				const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+				if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+					state.output = state.output.slice(0, -prev.output.length);
+					prev.type = "star";
+					prev.value = "*";
+					prev.output = star;
+					state.output += prev.output;
+				}
+			}
+			if (extglobs.length && tok.type !== "paren") extglobs[extglobs.length - 1].inner += tok.value;
+			if (tok.value || tok.output) append(tok);
+			if (prev && prev.type === "text" && tok.type === "text") {
+				prev.value += tok.value;
+				prev.output = (prev.output || "") + tok.value;
+				return;
+			}
+			tok.prev = prev;
+			tokens.push(tok);
+			prev = tok;
+		};
+		const extglobOpen = (type, value) => {
+			const token = {
+				...EXTGLOB_CHARS[value],
+				conditions: 1,
+				inner: ""
+			};
+			token.prev = prev;
+			token.parens = state.parens;
+			token.output = state.output;
+			const output = (opts.capture ? "(" : "") + token.open;
+			increment("parens");
+			push({
+				type,
+				value,
+				output: state.output ? "" : ONE_CHAR
+			});
+			push({
+				type: "paren",
+				extglob: true,
+				value: advance(),
+				output
+			});
+			extglobs.push(token);
+		};
+		const extglobClose = (token) => {
+			let output = token.close + (opts.capture ? ")" : "");
+			let rest;
+			if (token.type === "negate") {
+				let extglobStar = star;
+				if (token.inner && token.inner.length > 1 && token.inner.includes("/")) extglobStar = globstar(opts);
+				if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) output = token.close = `)$))${extglobStar}`;
+				if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) output = token.close = `)${parse(rest, {
+					...options,
+					fastpaths: false
+				}).output})${extglobStar})`;
+				if (token.prev.type === "bos") state.negatedExtglob = true;
+			}
+			push({
+				type: "paren",
+				extglob: true,
+				value,
+				output
+			});
+			decrement("parens");
+		};
+		/**
+		* Fast paths
+		*/
+		if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+			let backslashes = false;
+			let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+				if (first === "\\") {
+					backslashes = true;
+					return m;
+				}
+				if (first === "?") {
+					if (esc) return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+					if (index === 0) return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+					return QMARK.repeat(chars.length);
+				}
+				if (first === ".") return DOT_LITERAL.repeat(chars.length);
+				if (first === "*") {
+					if (esc) return esc + first + (rest ? star : "");
+					return star;
+				}
+				return esc ? m : `\\${m}`;
+			});
+			if (backslashes === true) if (opts.unescape === true) output = output.replace(/\\/g, "");
+			else output = output.replace(/\\+/g, (m) => {
+				return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+			});
+			if (output === input && opts.contains === true) {
+				state.output = input;
+				return state;
+			}
+			state.output = utils.wrapOutput(output, state, options);
+			return state;
+		}
+		/**
+		* Tokenize input until we reach end-of-string
+		*/
+		while (!eos()) {
+			value = advance();
+			if (value === "\0") continue;
+			/**
+			* Escaped characters
+			*/
+			if (value === "\\") {
+				const next = peek();
+				if (next === "/" && opts.bash !== true) continue;
+				if (next === "." || next === ";") continue;
+				if (!next) {
+					value += "\\";
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+				const match = /^\\+/.exec(remaining());
+				let slashes = 0;
+				if (match && match[0].length > 2) {
+					slashes = match[0].length;
+					state.index += slashes;
+					if (slashes % 2 !== 0) value += "\\";
+				}
+				if (opts.unescape === true) value = advance();
+				else value += advance();
+				if (state.brackets === 0) {
+					push({
+						type: "text",
+						value
+					});
+					continue;
+				}
+			}
+			/**
+			* If we're inside a regex character class, continue
+			* until we reach the closing bracket.
+			*/
+			if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+				if (opts.posix !== false && value === ":") {
+					const inner = prev.value.slice(1);
+					if (inner.includes("[")) {
+						prev.posix = true;
+						if (inner.includes(":")) {
+							const idx = prev.value.lastIndexOf("[");
+							const pre = prev.value.slice(0, idx);
+							const posix = POSIX_REGEX_SOURCE[prev.value.slice(idx + 2)];
+							if (posix) {
+								prev.value = pre + posix;
+								state.backtrack = true;
+								advance();
+								if (!bos.output && tokens.indexOf(prev) === 1) bos.output = ONE_CHAR;
+								continue;
+							}
+						}
+					}
+				}
+				if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") value = `\\${value}`;
+				if (value === "]" && (prev.value === "[" || prev.value === "[^")) value = `\\${value}`;
+				if (opts.posix === true && value === "!" && prev.value === "[") value = "^";
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* If we're inside a quoted string, continue
+			* until we reach the closing double quote.
+			*/
+			if (state.quotes === 1 && value !== "\"") {
+				value = utils.escapeRegex(value);
+				prev.value += value;
+				append({ value });
+				continue;
+			}
+			/**
+			* Double quotes
+			*/
+			if (value === "\"") {
+				state.quotes = state.quotes === 1 ? 0 : 1;
+				if (opts.keepQuotes === true) push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Parentheses
+			*/
+			if (value === "(") {
+				increment("parens");
+				push({
+					type: "paren",
+					value
+				});
+				continue;
+			}
+			if (value === ")") {
+				if (state.parens === 0 && opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "("));
+				const extglob = extglobs[extglobs.length - 1];
+				if (extglob && state.parens === extglob.parens + 1) {
+					extglobClose(extglobs.pop());
+					continue;
+				}
+				push({
+					type: "paren",
+					value,
+					output: state.parens ? ")" : "\\)"
+				});
+				decrement("parens");
+				continue;
+			}
+			/**
+			* Square brackets
+			*/
+			if (value === "[") {
+				if (opts.nobracket === true || !remaining().includes("]")) {
+					if (opts.nobracket !== true && opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+					value = `\\${value}`;
+				} else increment("brackets");
+				push({
+					type: "bracket",
+					value
+				});
+				continue;
+			}
+			if (value === "]") {
+				if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				if (state.brackets === 0) {
+					if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("opening", "["));
+					push({
+						type: "text",
+						value,
+						output: `\\${value}`
+					});
+					continue;
+				}
+				decrement("brackets");
+				const prevValue = prev.value.slice(1);
+				if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) value = `/${value}`;
+				prev.value += value;
+				append({ value });
+				if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) continue;
+				const escaped = utils.escapeRegex(prev.value);
+				state.output = state.output.slice(0, -prev.value.length);
+				if (opts.literalBrackets === true) {
+					state.output += escaped;
+					prev.value = escaped;
+					continue;
+				}
+				prev.value = `(${capture}${escaped}|${prev.value})`;
+				state.output += prev.value;
+				continue;
+			}
+			/**
+			* Braces
+			*/
+			if (value === "{" && opts.nobrace !== true) {
+				increment("braces");
+				const open = {
+					type: "brace",
+					value,
+					output: "(",
+					outputIndex: state.output.length,
+					tokensIndex: state.tokens.length
+				};
+				braces.push(open);
+				push(open);
+				continue;
+			}
+			if (value === "}") {
+				const brace = braces[braces.length - 1];
+				if (opts.nobrace === true || !brace) {
+					push({
+						type: "text",
+						value,
+						output: value
+					});
+					continue;
+				}
+				let output = ")";
+				if (brace.dots === true) {
+					const arr = tokens.slice();
+					const range = [];
+					for (let i = arr.length - 1; i >= 0; i--) {
+						tokens.pop();
+						if (arr[i].type === "brace") break;
+						if (arr[i].type !== "dots") range.unshift(arr[i].value);
+					}
+					output = expandRange(range, opts);
+					state.backtrack = true;
+				}
+				if (brace.comma !== true && brace.dots !== true) {
+					const out = state.output.slice(0, brace.outputIndex);
+					const toks = state.tokens.slice(brace.tokensIndex);
+					brace.value = brace.output = "\\{";
+					value = output = "\\}";
+					state.output = out;
+					for (const t of toks) state.output += t.output || t.value;
+				}
+				push({
+					type: "brace",
+					value,
+					output
+				});
+				decrement("braces");
+				braces.pop();
+				continue;
+			}
+			/**
+			* Pipes
+			*/
+			if (value === "|") {
+				if (extglobs.length > 0) extglobs[extglobs.length - 1].conditions++;
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Commas
+			*/
+			if (value === ",") {
+				let output = value;
+				const brace = braces[braces.length - 1];
+				if (brace && stack[stack.length - 1] === "braces") {
+					brace.comma = true;
+					output = "|";
+				}
+				push({
+					type: "comma",
+					value,
+					output
+				});
+				continue;
+			}
+			/**
+			* Slashes
+			*/
+			if (value === "/") {
+				if (prev.type === "dot" && state.index === state.start + 1) {
+					state.start = state.index + 1;
+					state.consumed = "";
+					state.output = "";
+					tokens.pop();
+					prev = bos;
+					continue;
+				}
+				push({
+					type: "slash",
+					value,
+					output: SLASH_LITERAL
+				});
+				continue;
+			}
+			/**
+			* Dots
+			*/
+			if (value === ".") {
+				if (state.braces > 0 && prev.type === "dot") {
+					if (prev.value === ".") prev.output = DOT_LITERAL;
+					const brace = braces[braces.length - 1];
+					prev.type = "dots";
+					prev.output += value;
+					prev.value += value;
+					brace.dots = true;
+					continue;
+				}
+				if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+					push({
+						type: "text",
+						value,
+						output: DOT_LITERAL
+					});
+					continue;
+				}
+				push({
+					type: "dot",
+					value,
+					output: DOT_LITERAL
+				});
+				continue;
+			}
+			/**
+			* Question marks
+			*/
+			if (value === "?") {
+				if (!(prev && prev.value === "(") && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("qmark", value);
+					continue;
+				}
+				if (prev && prev.type === "paren") {
+					const next = peek();
+					let output = value;
+					if (next === "<" && !utils.supportsLookbehinds()) throw new Error("Node.js v10 or higher is required for regex lookbehinds");
+					if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) output = `\\${value}`;
+					push({
+						type: "text",
+						value,
+						output
+					});
+					continue;
+				}
+				if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+					push({
+						type: "qmark",
+						value,
+						output: QMARK_NO_DOT
+					});
+					continue;
+				}
+				push({
+					type: "qmark",
+					value,
+					output: QMARK
+				});
+				continue;
+			}
+			/**
+			* Exclamation
+			*/
+			if (value === "!") {
+				if (opts.noextglob !== true && peek() === "(") {
+					if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+						extglobOpen("negate", value);
+						continue;
+					}
+				}
+				if (opts.nonegate !== true && state.index === 0) {
+					negate();
+					continue;
+				}
+			}
+			/**
+			* Plus
+			*/
+			if (value === "+") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					extglobOpen("plus", value);
+					continue;
+				}
+				if (prev && prev.value === "(" || opts.regex === false) {
+					push({
+						type: "plus",
+						value,
+						output: PLUS_LITERAL
+					});
+					continue;
+				}
+				if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+					push({
+						type: "plus",
+						value
+					});
+					continue;
+				}
+				push({
+					type: "plus",
+					value: PLUS_LITERAL
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value === "@") {
+				if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+					push({
+						type: "at",
+						extglob: true,
+						value,
+						output: ""
+					});
+					continue;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Plain text
+			*/
+			if (value !== "*") {
+				if (value === "$" || value === "^") value = `\\${value}`;
+				const match = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+				if (match) {
+					value += match[0];
+					state.index += match[0].length;
+				}
+				push({
+					type: "text",
+					value
+				});
+				continue;
+			}
+			/**
+			* Stars
+			*/
+			if (prev && (prev.type === "globstar" || prev.star === true)) {
+				prev.type = "star";
+				prev.star = true;
+				prev.value += value;
+				prev.output = star;
+				state.backtrack = true;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			let rest = remaining();
+			if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+				extglobOpen("star", value);
+				continue;
+			}
+			if (prev.type === "star") {
+				if (opts.noglobstar === true) {
+					consume(value);
+					continue;
+				}
+				const prior = prev.prev;
+				const before = prior.prev;
+				const isStart = prior.type === "slash" || prior.type === "bos";
+				const afterStar = before && (before.type === "star" || before.type === "globstar");
+				if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+				const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+				if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+					push({
+						type: "star",
+						value,
+						output: ""
+					});
+					continue;
+				}
+				while (rest.slice(0, 3) === "/**") {
+					const after = input[state.index + 4];
+					if (after && after !== "/") break;
+					rest = rest.slice(3);
+					consume("/**", 3);
+				}
+				if (prior.type === "bos" && eos()) {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = globstar(opts);
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+					prev.value += value;
+					state.globstar = true;
+					state.output += prior.output + prev.output;
+					consume(value);
+					continue;
+				}
+				if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+					const end = rest[1] !== void 0 ? "|$" : "";
+					state.output = state.output.slice(0, -(prior.output + prev.output).length);
+					prior.output = `(?:${prior.output}`;
+					prev.type = "globstar";
+					prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+					prev.value += value;
+					state.output += prior.output + prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				if (prior.type === "bos" && rest[0] === "/") {
+					prev.type = "globstar";
+					prev.value += value;
+					prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+					state.output = prev.output;
+					state.globstar = true;
+					consume(value + advance());
+					push({
+						type: "slash",
+						value: "/",
+						output: ""
+					});
+					continue;
+				}
+				state.output = state.output.slice(0, -prev.output.length);
+				prev.type = "globstar";
+				prev.output = globstar(opts);
+				prev.value += value;
+				state.output += prev.output;
+				state.globstar = true;
+				consume(value);
+				continue;
+			}
+			const token = {
+				type: "star",
+				value,
+				output: star
+			};
+			if (opts.bash === true) {
+				token.output = ".*?";
+				if (prev.type === "bos" || prev.type === "slash") token.output = nodot + token.output;
+				push(token);
+				continue;
+			}
+			if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+				token.output = value;
+				push(token);
+				continue;
+			}
+			if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+				if (prev.type === "dot") {
+					state.output += NO_DOT_SLASH;
+					prev.output += NO_DOT_SLASH;
+				} else if (opts.dot === true) {
+					state.output += NO_DOTS_SLASH;
+					prev.output += NO_DOTS_SLASH;
+				} else {
+					state.output += nodot;
+					prev.output += nodot;
+				}
+				if (peek() !== "*") {
+					state.output += ONE_CHAR;
+					prev.output += ONE_CHAR;
+				}
+			}
+			push(token);
+		}
+		while (state.brackets > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+			state.output = utils.escapeLast(state.output, "[");
+			decrement("brackets");
+		}
+		while (state.parens > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+			state.output = utils.escapeLast(state.output, "(");
+			decrement("parens");
+		}
+		while (state.braces > 0) {
+			if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+			state.output = utils.escapeLast(state.output, "{");
+			decrement("braces");
+		}
+		if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) push({
+			type: "maybe_slash",
+			value: "",
+			output: `${SLASH_LITERAL}?`
+		});
+		if (state.backtrack === true) {
+			state.output = "";
+			for (const token of state.tokens) {
+				state.output += token.output != null ? token.output : token.value;
+				if (token.suffix) state.output += token.suffix;
+			}
+		}
+		return state;
+	};
+	/**
+	* Fast paths for creating regular expressions for common glob patterns.
+	* This can significantly speed up processing and has very little downside
+	* impact when none of the fast paths match.
+	*/
+	parse.fastpaths = (input, options) => {
+		const opts = { ...options };
+		const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+		const len = input.length;
+		if (len > max) throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+		input = REPLACEMENTS[input] || input;
+		const win32 = utils.isWindows(options);
+		const { DOT_LITERAL, SLASH_LITERAL, ONE_CHAR, DOTS_SLASH, NO_DOT, NO_DOTS, NO_DOTS_SLASH, STAR, START_ANCHOR } = constants.globChars(win32);
+		const nodot = opts.dot ? NO_DOTS : NO_DOT;
+		const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+		const capture = opts.capture ? "" : "?:";
+		const state = {
+			negated: false,
+			prefix: ""
+		};
+		let star = opts.bash === true ? ".*?" : STAR;
+		if (opts.capture) star = `(${star})`;
+		const globstar = (opts) => {
+			if (opts.noglobstar === true) return star;
+			return `(${capture}(?:(?!${START_ANCHOR}${opts.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+		};
+		const create = (str) => {
+			switch (str) {
+				case "*": return `${nodot}${ONE_CHAR}${star}`;
+				case ".*": return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*.*": return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "*/*": return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+				case "**": return nodot + globstar(opts);
+				case "**/*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+				case "**/*.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+				case "**/.*": return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+				default: {
+					const match = /^(.*?)\.(\w+)$/.exec(str);
+					if (!match) return;
+					const source = create(match[1]);
+					if (!source) return;
+					return source + DOT_LITERAL + match[2];
+				}
+			}
+		};
+		let source = create(utils.removePrefix(input, state));
+		if (source && opts.strictSlashes !== true) source += `${SLASH_LITERAL}?`;
+		return source;
+	};
+	module.exports = parse;
+}));
+//#endregion
+//#region node_modules/picomatch/lib/picomatch.js
+var require_picomatch$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	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 = utils.isWindows(options);
+		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, posix = utils.isWindows(options)) => {
+		return (glob instanceof RegExp ? glob : picomatch.makeRe(glob, options)).test(path$1.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;
+}));
+//#endregion
+//#region src/diff-filter.ts
+var import_picomatch = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = require_picomatch$1();
+})))(), 1);
+function filterGitDiff(diff, config) {
+	const isIncluded = (0, import_picomatch.default)(config.include);
+	const isExcluded = (0, import_picomatch.default)(config.exclude);
+	const matches = (filePath) => isIncluded(filePath) && !isExcluded(filePath);
+	const toIndex = [];
+	const toDelete = [];
+	const renamed = [];
+	for (const filePath of [...diff.added, ...diff.modified]) if (matches(filePath)) toIndex.push(filePath);
+	for (const filePath of diff.deleted) if (matches(filePath)) toDelete.push(filePath);
+	for (const r of diff.renamed) {
+		const fromMatches = matches(r.from);
+		const toMatches = matches(r.to);
+		if (toMatches) renamed.push(r);
+		if (fromMatches && !toMatches) toDelete.push(r.from);
+	}
+	return {
+		toIndex,
+		toDelete,
+		renamed
+	};
+}
+//#endregion
+//#region src/parser/base.ts
+var BaseParser = class {
+	supports(filePath) {
+		return this.extensions.some((ext) => filePath.endsWith(ext));
+	}
+};
+//#endregion
+//#region src/parser/swift.ts
+const swiftParser = new Parser();
+swiftParser.setLanguage(Swift);
+const SYMBOL_NODE_TYPES$1 = {
+	class_declaration: "class",
+	protocol_declaration: "protocol",
+	function_declaration: "function"
+};
+const KEYWORD_TO_KIND = {
+	struct: "struct",
+	enum: "enum",
+	class: "class"
+};
+function extractName$1(node) {
+	/* v8 ignore next */
+	return node.childForFieldName("name")?.text ?? null;
+}
+var SwiftParser = class extends BaseParser {
+	extensions = [".swift"];
+	parse(content, _filePath) {
+		const rootNode = swiftParser.parse(content).rootNode;
+		const imports = [];
+		const exports = [];
+		const symbols = [];
+		function walk(node) {
+			if (node.type === "import_declaration") {
+				const children = node.children.filter((c) => c.type !== "import");
+				/* v8 ignore next */
+				if (children.length > 0) imports.push(children.map((c) => c.text).join("."));
+			}
+			let kind = SYMBOL_NODE_TYPES$1[node.type];
+			if (node.type === "class_declaration") {
+				const keyword = node.children.find((c) => c.type in KEYWORD_TO_KIND);
+				/* v8 ignore next */
+				kind = keyword ? KEYWORD_TO_KIND[keyword.type] : "class";
+			}
+			if (kind) {
+				const name = extractName$1(node);
+				/* v8 ignore next */
+				if (name) {
+					symbols.push({
+						name,
+						kind,
+						description: ""
+					});
+					exports.push(name);
+				}
+			}
+			for (const child of node.children) walk(child);
+		}
+		walk(rootNode);
+		return {
+			imports,
+			exports,
+			symbols
+		};
+	}
+};
+//#endregion
+//#region src/parser/typescript.ts
+const tsParser = new Parser();
+tsParser.setLanguage(TypeScript.typescript);
+const tsxParser = new Parser();
+tsxParser.setLanguage(TypeScript.tsx);
+const IMPORT_TYPES = new Set(["import_statement"]);
+const EXPORT_NODE_TYPES = new Set(["export_statement"]);
+const SYMBOL_NODE_TYPES = {
+	class_declaration: "class",
+	function_declaration: "function",
+	method_definition: "method",
+	interface_declaration: "interface",
+	type_alias_declaration: "type",
+	enum_declaration: "enum",
+	lexical_declaration: "variable",
+	variable_declaration: "variable"
+};
+function extractName(node) {
+	const nameNode = node.childForFieldName("name");
+	if (nameNode) return nameNode.text;
+	for (const child of node.children) if (child.type === "variable_declarator") {
+		const n = child.childForFieldName("name");
+		/* v8 ignore next */
+		if (n) return n.text;
+	}
+	/* v8 ignore next */
+	return null;
+}
+function extractImports(rootNode) {
+	const imports = [];
+	for (const child of rootNode.children) if (IMPORT_TYPES.has(child.type)) {
+		const source = child.childForFieldName("source");
+		/* v8 ignore next */
+		if (source) imports.push(source.text.replace(/['"]/g, ""));
+	}
+	return imports;
+}
+function extractExports(rootNode) {
+	const exports = [];
+	for (const child of rootNode.children) if (EXPORT_NODE_TYPES.has(child.type)) {
+		const exportClause = child.children.find((c) => c.type === "export_clause");
+		if (exportClause) {
+			for (const specifier of exportClause.children) if (specifier.type === "export_specifier") {
+				const name = specifier.childForFieldName("name");
+				/* v8 ignore next */
+				if (name) exports.push(name.text);
+			}
+			continue;
+		}
+		const declaration = child.childForFieldName("declaration");
+		if (declaration) {
+			const name = extractName(declaration);
+			/* v8 ignore next */
+			if (name) exports.push(name);
+		}
+	}
+	return exports;
+}
+function extractSymbols(rootNode) {
+	const symbols = [];
+	function walk(node) {
+		if (EXPORT_NODE_TYPES.has(node.type)) {
+			const declaration = node.childForFieldName("declaration");
+			if (declaration) processSymbolNode(declaration);
+			return;
+		}
+		processSymbolNode(node);
+		for (const child of node.children) if (child.type === "class_body") for (const member of child.children) processSymbolNode(member);
+	}
+	function processSymbolNode(node) {
+		const kind = SYMBOL_NODE_TYPES[node.type];
+		if (!kind) return;
+		const name = extractName(node);
+		/* v8 ignore next */
+		if (!name) return;
+		symbols.push({
+			name,
+			kind,
+			description: ""
+		});
+	}
+	for (const child of rootNode.children) walk(child);
+	return symbols;
+}
+var TypeScriptParser = class extends BaseParser {
+	extensions = [
+		".ts",
+		".tsx",
+		".js",
+		".jsx"
+	];
+	parse(content, filePath) {
+		const rootNode = (filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? tsxParser : tsParser).parse(content).rootNode;
+		return {
+			imports: extractImports(rootNode),
+			exports: extractExports(rootNode),
+			symbols: extractSymbols(rootNode)
+		};
+	}
+};
+//#endregion
+//#region src/parser/index.ts
+const EXTENSION_TO_LANGUAGE = {
+	".ts": "typescript",
+	".tsx": "typescript",
+	".js": "javascript",
+	".jsx": "javascript",
+	".swift": "swift"
+};
+var ParserManager = class {
+	parsers;
+	constructor() {
+		this.parsers = [new TypeScriptParser(), new SwiftParser()];
+	}
+	getParser(filePath) {
+		return this.parsers.find((p) => p.supports(filePath));
+	}
+	parse(content, filePath) {
+		const parser = this.getParser(filePath);
+		if (!parser) return null;
+		return parser.parse(content, filePath);
+	}
+	getLanguage(filePath) {
+		return EXTENSION_TO_LANGUAGE[filePath.slice(filePath.lastIndexOf("."))];
+	}
+};
+//#endregion
+//#region src/llm/batcher.ts
+var Batcher = class {
+	limit;
+	constructor(concurrency = 5) {
+		this.limit = pLimit(concurrency);
+	}
+	async run(tasks) {
+		return Promise.all(tasks.map((task) => this.limit(() => task.execute())));
+	}
+};
+//#endregion
+//#region src/llm/prompts.ts
+const INDEXING_SYSTEM_PROMPT = `You are a code indexing assistant. Your job is to analyze source code files and generate structured metadata.
+
+For each file, you must return a JSON object with exactly these fields:
+- "name": A short, descriptive name for the file (e.g., "User Authentication Service")
+- "description": A one-line description of what this file does
+- "summary": A 2-3 sentence summary of the file's purpose and key functionality
+- "symbols": An array of symbol descriptions, each with "name" and "description"
+
+Rules:
+- Be concise and precise
+- Focus on what the code DOES, not how it's structured
+- Symbol descriptions should explain the purpose, not restate the signature
+- Return ONLY valid JSON, no markdown or explanation`;
+const RERANK_SYSTEM_PROMPT = `You are a search result reranking assistant. Given a user query and a list of candidate files, reorder them by relevance.
+
+Return ONLY a JSON array of file paths, ordered from most relevant to least relevant.
+Do not include any explanation, markdown, or extra text — just the JSON array.`;
+function buildRerankPrompt(query, candidates) {
+	return `User query: "${query}"
+
+Candidate files:
+${candidates.map((c, i) => `${i + 1}. ${c.path}\n   Name: ${c.name}\n   Description: ${c.description}\n   Summary: ${c.summary}`).join("\n\n")}
+
+Reorder these files by relevance to the query. Return a JSON array of file paths, most relevant first.`;
+}
+function buildIndexingPrompt(filePath, content, symbols) {
+	return `Analyze this source file and generate indexing metadata.
+
+File: ${filePath}
+Detected symbols:
+${symbols.map((s) => `- ${s.kind}: ${s.name}`).join("\n")}
+
+Source code:
+\`\`\`
+${content}
+\`\`\`
+
+Return a JSON object with: name, description, summary, and symbols (array with name + description for each detected symbol).`;
+}
+//#endregion
+//#region src/llm/index.ts
+/**
+* Resolve a model by provider and model ID from user config.
+* pi-ai's getModel is generic over compile-time known providers/models,
+* but user config is dynamic. This wrapper bridges the gap.
+*/
+function resolveModel(provider, modelId) {
+	const model = getModel(provider, modelId);
+	if (!model) throw new Error(`Unknown model "${modelId}" for provider "${provider}". Check your .kly/config.yaml.`);
+	return model;
+}
+var LLMService = class {
+	model;
+	batcher;
+	constructor(config) {
+		const envKey = this.getEnvKeyName(config.llm.provider);
+		if (config.llm.apiKey && !process.env[envKey]) process.env[envKey] = config.llm.apiKey;
+		this.model = resolveModel(config.llm.provider, config.llm.model);
+		this.batcher = new Batcher(5);
+	}
+	getEnvKeyName(provider) {
+		return {
+			openrouter: "OPENROUTER_API_KEY",
+			anthropic: "ANTHROPIC_API_KEY",
+			openai: "OPENAI_API_KEY",
+			google: "GOOGLE_API_KEY",
+			mistral: "MISTRAL_API_KEY",
+			groq: "GROQ_API_KEY",
+			xai: "XAI_API_KEY"
+		}[provider] || `${provider.toUpperCase()}_API_KEY`;
+	}
+	async indexFile(filePath, content, symbols) {
+		const prompt = buildIndexingPrompt(filePath, content, symbols.map((s) => ({
+			name: s.name,
+			kind: s.kind
+		})));
+		const text = (await complete(this.model, {
+			systemPrompt: INDEXING_SYSTEM_PROMPT,
+			messages: [{
+				role: "user",
+				content: prompt,
+				timestamp: Date.now()
+			}]
+		})).content.filter((block) => block.type === "text").map((block) => block.text).join("");
+		return this.parseResponse(text);
+	}
+	async indexFiles(files) {
+		const results = /* @__PURE__ */ new Map();
+		const tasks = files.map((file) => ({ execute: async () => {
+			const result = await this.indexFile(file.path, file.content, file.symbols);
+			results.set(file.path, result);
+			return result;
+		} }));
+		await this.batcher.run(tasks);
+		return results;
+	}
+	parseResponse(text) {
+		const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+		const jsonStr = jsonMatch ? jsonMatch[1].trim() : text.trim();
+		const parsed = JSON.parse(jsonStr);
+		return {
+			name: parsed.name || "",
+			description: parsed.description || "",
+			summary: parsed.summary || "",
+			symbols: Array.isArray(parsed.symbols) ? parsed.symbols.map((s) => ({
+				name: s.name || "",
+				description: s.description || ""
+			})) : []
+		};
+	}
+};
+//#endregion
+//#region src/graph.ts
+const RESOLVE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	"/index.ts",
+	"/index.tsx",
+	"/index.js",
+	"/index.jsx"
+];
+function isRelativeImport(importPath) {
+	return importPath.startsWith(".") || importPath.startsWith("/");
+}
+/**
+* Resolve a relative import path to a file path that exists in the index.
+*/
+function resolveImport(fromFile, importPath, indexedPaths) {
+	if (!isRelativeImport(importPath)) return void 0;
+	const dir = path.dirname(fromFile);
+	const resolved = path.normalize(path.join(dir, importPath));
+	if (indexedPaths.has(resolved)) return resolved;
+	for (const ext of RESOLVE_EXTENSIONS) {
+		const candidate = resolved + ext;
+		if (indexedPaths.has(candidate)) return candidate;
+	}
+}
+/**
+* Build a dependency graph from indexed files.
+*/
+function buildDependencyGraph(db, options = {}) {
+	const { focus, depth = 2 } = options;
+	const allFiles = db.getAllFiles();
+	const indexedPaths = new Set(allFiles.map((f) => f.path));
+	const fileMap = /* @__PURE__ */ new Map();
+	for (const file of allFiles) fileMap.set(file.path, file);
+	const adjacency = /* @__PURE__ */ new Map();
+	for (const file of allFiles) {
+		const deps = [];
+		for (const imp of file.imports) {
+			const resolved = resolveImport(file.path, imp, indexedPaths);
+			if (resolved) deps.push(resolved);
+		}
+		adjacency.set(file.path, deps);
+	}
+	let includedPaths;
+	if (focus) {
+		includedPaths = /* @__PURE__ */ new Set();
+		const queue = [{
+			path: focus,
+			currentDepth: 0
+		}];
+		includedPaths.add(focus);
+		while (queue.length > 0) {
+			const { path: current, currentDepth } = queue.shift();
+			if (currentDepth >= depth) continue;
+			const deps = adjacency.get(current) || [];
+			for (const dep of deps) if (!includedPaths.has(dep)) {
+				includedPaths.add(dep);
+				queue.push({
+					path: dep,
+					currentDepth: currentDepth + 1
+				});
+			}
+			for (const [source, targets] of adjacency) if (targets.includes(current) && !includedPaths.has(source)) {
+				includedPaths.add(source);
+				queue.push({
+					path: source,
+					currentDepth: currentDepth + 1
+				});
+			}
+		}
+	} else includedPaths = indexedPaths;
+	const nodes = /* @__PURE__ */ new Map();
+	const edges = [];
+	for (const filePath of includedPaths) {
+		const file = fileMap.get(filePath);
+		if (!file) continue;
+		nodes.set(filePath, {
+			path: file.path,
+			name: file.name,
+			language: file.language
+		});
+	}
+	for (const filePath of includedPaths) {
+		const deps = adjacency.get(filePath) || [];
+		for (const dep of deps) if (includedPaths.has(dep)) edges.push({
+			from: filePath,
+			to: dep
+		});
+	}
+	return {
+		nodes,
+		edges
+	};
+}
+/**
+* Generate Mermaid syntax from a dependency graph.
+*/
+function generateMermaid(graph) {
+	const lines = ["graph LR"];
+	const nodeIds = /* @__PURE__ */ new Map();
+	let idCounter = 0;
+	for (const filePath of graph.nodes.keys()) nodeIds.set(filePath, `N${idCounter++}`);
+	for (const [filePath, node] of graph.nodes) {
+		const id = nodeIds.get(filePath);
+		const label = node.path.replace(/"/g, "'");
+		lines.push(`  ${id}["${label}"]`);
+	}
+	for (const edge of graph.edges) {
+		const fromId = nodeIds.get(edge.from);
+		const toId = nodeIds.get(edge.to);
+		if (fromId && toId) lines.push(`  ${fromId} --> ${toId}`);
+	}
+	return lines.join("\n");
+}
+/**
+* Render a Mermaid diagram string to ASCII/Unicode art.
+*/
+function renderGraphAscii(mermaid) {
+	return renderMermaidASCII(mermaid, { colorMode: "none" });
+}
+/**
+* Render a Mermaid diagram string to SVG.
+*/
+function renderGraphSvg(mermaid) {
+	return renderMermaidSVG(mermaid, { transparent: true });
+}
+//#endregion
+//#region src/indexer.ts
+function emptyBuildResult(root) {
+	const gitRepo = isGitRepo(root);
+	return {
+		totalFiles: 0,
+		newFiles: 0,
+		updatedFiles: 0,
+		deletedFiles: 0,
+		unchangedFiles: 0,
+		branch: gitRepo ? getCurrentBranch(root) || "detached" : "default",
+		commit: gitRepo ? getCurrentCommit(root) : "",
+		durationMs: 0
+	};
+}
+async function buildIndex(root, options = {}) {
+	const start = Date.now();
+	const config = loadConfig(root);
+	const parserManager = new ParserManager();
+	const llmService = new LLMService(config);
+	const gitRepo = isGitRepo(root);
+	let result;
+	if (gitRepo && !options.full) result = await buildGitAware(root, config, parserManager, llmService, options);
+	else result = await buildClassic(root, config, parserManager, llmService, options);
+	result.durationMs = Date.now() - start;
+	return result;
+}
+async function buildGitAware(root, config, parserManager, llmService, options) {
+	const branch = getCurrentBranch(root);
+	const commit = getCurrentCommit(root);
+	const dbName = branchToDbName(branch, commit);
+	const state = loadState(root);
+	const currentConfigHash = hashConfig(config);
+	let result;
+	if (state.configHash && state.configHash !== currentConfigHash) {
+		result = await buildClassic(root, config, parserManager, llmService, options, dbName);
+		state.configHash = currentConfigHash;
+		setBranchState(state, dbName, {
+			lastCommit: commit,
+			lastBuilt: Date.now()
+		});
+		saveState(root, state);
+		return result;
+	}
+	const branchState = getBranchState(state, dbName);
+	if (branchState?.lastCommit) if (isAncestor(root, branchState.lastCommit, commit)) result = await buildFromGitDiff(root, config, parserManager, llmService, options, dbName, branchState.lastCommit, commit);
+	else result = await buildClassic(root, config, parserManager, llmService, options, dbName);
+	else {
+		const forkedFromDb = tryForkFromParent(root, dbName, state);
+		if (forkedFromDb) {
+			setBranchState(state, dbName, {
+				lastCommit: "",
+				lastBuilt: 0,
+				forkedFrom: forkedFromDb
+			});
+			const mergeBase = getMergeBase(root, getBranchState(state, forkedFromDb).lastCommit, commit);
+			if (mergeBase) result = await buildFromGitDiff(root, config, parserManager, llmService, options, dbName, mergeBase, commit);
+			else result = await buildClassic(root, config, parserManager, llmService, options, dbName);
+		} else result = await buildClassic(root, config, parserManager, llmService, options, dbName);
+	}
+	state.configHash = currentConfigHash;
+	const newBranchState = {
+		lastCommit: commit,
+		lastBuilt: Date.now()
+	};
+	const currentBranchState = getBranchState(state, dbName);
+	if (currentBranchState?.forkedFrom) newBranchState.forkedFrom = currentBranchState.forkedFrom;
+	setBranchState(state, dbName, newBranchState);
+	saveState(root, state);
+	return result;
+}
+function tryForkFromParent(root, dbName, state) {
+	for (const candidate of ["main", "master"]) if (state.branches[candidate] && candidate !== dbName) {
+		copyDatabase(root, candidate, dbName);
+		return candidate;
+	}
+	return null;
+}
+async function buildFromGitDiff(root, config, parserManager, llmService, options, dbName, fromCommit, toCommit) {
+	const filtered = filterGitDiff(getChangedFiles(root, fromCommit, toCommit), config);
+	const toIndex = [...filtered.toIndex];
+	const toDelete = [...filtered.toDelete];
+	for (const r of filtered.renamed) {
+		toIndex.push(r.to);
+		toDelete.push(r.from);
+	}
+	const db = openDatabase(root, dbName);
+	const result = emptyBuildResult(root);
+	try {
+		if (toDelete.length > 0) {
+			db.removeFiles(toDelete);
+			db.removeDependenciesBatch(toDelete);
+			result.deletedFiles = toDelete.length;
+		}
+		if (toIndex.length === 0) {
+			options.onProgress?.({
+				total: 0,
+				completed: 0,
+				current: "",
+				skipped: 0
+			});
+			result.totalFiles = db.getFileCount();
+			result.unchangedFiles = result.totalFiles;
+			return result;
+		}
+		const indexResult = await indexFiles(root, toIndex, db, parserManager, llmService, options);
+		result.newFiles = indexResult.newFiles;
+		result.updatedFiles = indexResult.updatedFiles;
+		result.totalFiles = db.getFileCount();
+		result.unchangedFiles = result.totalFiles - result.newFiles - result.updatedFiles;
+		return result;
+	} finally {
+		db.close();
+	}
+}
+async function buildClassic(root, config, parserManager, llmService, options, dbName) {
+	const db = openDatabase(root, dbName || (isGitRepo(root) ? branchToDbName(getCurrentBranch(root), getCurrentCommit(root)) : "default"));
+	const result = emptyBuildResult(root);
+	try {
+		const files = await scanFiles(root, config);
+		const progress = {
+			total: files.length,
+			completed: 0,
+			current: "",
+			skipped: 0
+		};
+		const toIndex = [];
+		const existingPaths = /* @__PURE__ */ new Set();
+		for (const filePath of files) {
+			const hash = hashFile(root, filePath);
+			const existing = db.getFile(filePath);
+			if (existing) existingPaths.add(filePath);
+			if (existing && !hasChanged(existing.hash, hash) && !options.full) {
+				progress.skipped++;
+				progress.completed++;
+				result.unchangedFiles++;
+				options.onProgress?.(progress);
+				continue;
+			}
+			toIndex.push(filePath);
+		}
+		if (toIndex.length > 0) {
+			await indexFiles(root, toIndex, db, parserManager, llmService, options, progress);
+			for (const filePath of toIndex) if (existingPaths.has(filePath)) result.updatedFiles++;
+			else result.newFiles++;
+		}
+		const fileSet = new Set(files);
+		const toRemove = db.getAllFiles().filter((f) => !fileSet.has(f.path)).map((f) => f.path);
+		if (toRemove.length > 0) {
+			db.removeFiles(toRemove);
+			db.removeDependenciesBatch(toRemove);
+			result.deletedFiles = toRemove.length;
+		}
+		result.totalFiles = db.getFileCount();
+		return result;
+	} finally {
+		db.close();
+	}
+}
+async function indexFiles(root, filePaths, db, parserManager, llmService, options, progress) {
+	const prog = progress || {
+		total: filePaths.length,
+		completed: 0,
+		current: "",
+		skipped: 0
+	};
+	if (!progress) prog.total = filePaths.length;
+	const parsedFiles = filePaths.map((filePath) => {
+		const fullPath = path.join(root, filePath);
+		const content = fs.readFileSync(fullPath, "utf-8");
+		const hash = hashFile(root, filePath);
+		const language = parserManager.getLanguage(filePath);
+		const parseResult = parserManager.parse(content, filePath);
+		return {
+			path: filePath,
+			content,
+			hash,
+			language: language || "typescript",
+			imports: parseResult?.imports || [],
+			exports: parseResult?.exports || [],
+			symbols: parseResult?.symbols || []
+		};
+	});
+	const llmResults = await llmService.indexFiles(parsedFiles.map((f) => ({
+		path: f.path,
+		content: f.content,
+		symbols: f.symbols
+	})));
+	const fileIndexes = parsedFiles.map((file) => {
+		const llmResult = llmResults.get(file.path);
+		const fileIndex = {
+			path: file.path,
+			name: llmResult?.name || path.basename(file.path),
+			description: llmResult?.description || "",
+			language: file.language,
+			imports: file.imports,
+			exports: file.exports,
+			symbols: file.symbols.map((s) => {
+				const llmSymbol = llmResult?.symbols.find((ls) => ls.name === s.name);
+				return {
+					...s,
+					description: llmSymbol?.description || s.description
+				};
+			}),
+			summary: llmResult?.summary || "",
+			hash: file.hash,
+			indexedAt: Date.now()
+		};
+		prog.completed++;
+		prog.current = file.path;
+		options.onProgress?.(prog);
+		return fileIndex;
+	});
+	db.upsertFiles(fileIndexes);
+	const allFiles = db.getAllFiles();
+	const indexedPaths = new Set(allFiles.map((f) => f.path));
+	const depEntries = [];
+	for (const file of parsedFiles) {
+		const resolved = [];
+		for (const imp of file.imports) {
+			const target = resolveImport(file.path, imp, indexedPaths);
+			if (target) resolved.push(target);
+		}
+		depEntries.push({
+			fromPath: file.path,
+			toPaths: resolved
+		});
+	}
+	if (depEntries.length > 0) db.upsertBatchDependencies(depEntries);
+	return {
+		indexed: fileIndexes.length,
+		newFiles: 0,
+		updatedFiles: 0
+	};
+}
+//#endregion
+//#region src/llm/reranker.ts
+/**
+* Rerank search results using LLM.
+* Takes FTS5 candidates and returns them reordered by semantic relevance.
+*/
+async function rerankResults(model, query, candidates, topK = 10) {
+	if (candidates.length === 0) return [];
+	if (candidates.length <= 1) return candidates.slice(0, topK);
+	const rankedPaths = parseRerankResponse((await complete(model, {
+		systemPrompt: RERANK_SYSTEM_PROMPT,
+		messages: [{
+			role: "user",
+			content: buildRerankPrompt(query, candidates.map((c) => ({
+				path: c.file.path,
+				name: c.file.name,
+				description: c.file.description,
+				summary: c.file.summary
+			}))),
+			timestamp: Date.now()
+		}]
+	})).content.filter((block) => block.type === "text").map((block) => block.text).join(""));
+	const resultMap = /* @__PURE__ */ new Map();
+	for (const candidate of candidates) resultMap.set(candidate.file.path, candidate);
+	const reranked = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const filePath of rankedPaths) {
+		const result = resultMap.get(filePath);
+		if (result && !seen.has(filePath)) {
+			reranked.push(result);
+			seen.add(filePath);
+		}
+	}
+	for (const candidate of candidates) if (!seen.has(candidate.file.path)) {
+		reranked.push(candidate);
+		seen.add(candidate.file.path);
+	}
+	return reranked.slice(0, topK);
+}
+/**
+* Parse the LLM rerank response into an array of file paths.
+*/
+function parseRerankResponse(text) {
+	const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+	const jsonStr = jsonMatch ? jsonMatch[1].trim() : text.trim();
+	try {
+		const parsed = JSON.parse(jsonStr);
+		if (Array.isArray(parsed) && parsed.every((item) => typeof item === "string")) return parsed;
+	} catch {}
+	return jsonStr.split("\n").map((line) => line.replace(/^[\d.)\-\s"]+/, "").replace(/[",\s]+$/, "").trim()).filter((line) => line.length > 0 && (line.includes("/") || line.includes(".")));
+}
+//#endregion
+//#region src/query.ts
+function searchFiles(db, query, limit = 20) {
+	return db.searchFiles(query, limit);
+}
+async function searchFilesWithRerank(db, model, query, topK = 10) {
+	const candidates = db.searchFiles(query, 50);
+	if (candidates.length === 0) return [];
+	return rerankResults(model, query, candidates, topK);
+}
+function filterByLanguage(db, language) {
+	return db.getAllFiles().filter((f) => f.language === language);
+}
+function filterByPath(db, pathPattern) {
+	return db.getAllFiles().filter((f) => f.path.includes(pathPattern));
+}
+//#endregion
+//#region src/enrich.ts
+/**
+* Enrich error stack frames with file descriptions, dependencies, and git history.
+*
+* For each frame, looks up the file in the kly index and augments it with:
+* - File description, summary, symbols, language (from index)
+* - importedBy / importsFrom (from dependencies table)
+* - Recent git commits (from git log)
+*
+* Frames whose files are not in the index are included with empty/default values.
+*/
+function enrichErrorStack(db, root, frames) {
+	const allImportedBy = /* @__PURE__ */ new Set();
+	const enrichedFrames = [];
+	for (const frame of frames) {
+		const fileIndex = db.getFile(frame.file);
+		const importedBy = db.getDependents(frame.file);
+		const importsFrom = db.getDependencies(frame.file);
+		const commits = getFileHistory(root, frame.file, 5);
+		for (const dep of importedBy) allImportedBy.add(dep);
+		enrichedFrames.push({
+			file: frame.file,
+			line: frame.line,
+			column: frame.column,
+			function: frame.function,
+			fileDescription: fileIndex?.description ?? "",
+			fileSummary: fileIndex?.summary ?? "",
+			symbols: fileIndex?.symbols ?? [],
+			language: fileIndex?.language ?? "typescript",
+			importedBy,
+			importsFrom,
+			lastModified: commits[0] ?? null,
+			recentCommits: commits
+		});
+	}
+	return {
+		frames: enrichedFrames,
+		affectedFiles: allImportedBy.size
+	};
+}
+//#endregion
+export { getCurrentBranch as A, getConfigPath as B, openDatabase as C, setBranchState as D, saveState as E, isGitRepo as F, hashConfig as G, getDbPath as H, hasChanged as I, loadConfig as J, initKlyDir as K, hashFile as L, getFileHistory as M, getMergeBase as N, branchToDbName as O, isAncestor as P, scanFiles as R, loadState as S, resolveDbName as T, getKlyDir as U, getDbDir as V, getStatePath as W, copyDatabase as _, searchFilesWithRerank as a, getFileFromDb as b, buildDependencyGraph as c, renderGraphAscii as d, renderGraphSvg as f, filterGitDiff as g, ParserManager as h, searchFiles as i, getCurrentCommit as j, getChangedFiles as k, generateMermaid as l, LLMService as m, filterByLanguage as n, rerankResults as o, resolveImport as p, isInitialized as q, filterByPath as r, buildIndex as s, enrichErrorStack as t, isRelativeImport as u, getAllFilesFromDb as v, removeBranchDb as w, listBranchDbs as x, getBranchState as y, IndexDatabase as z };
+
+//# sourceMappingURL=enrich-BHaZ2daX.mjs.map