@configdirector/cli 0.0.0-stage → 0.1.0-beta.1

package/dist/configdirector.mjs

@@ -0,0 +1,2912 @@
+#!/usr/bin/env node
+import { homedir } from "node:os";
+import { Command, CommanderError } from "commander";
+import { access, mkdir, open, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import * as v from "valibot";
+import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { createInterface } from "node:readline";
+import ignore from "ignore";
+import picomatch from "picomatch";
+//#region package.json
+var version = "0.1.0-beta.1";
+//#endregion
+//#region src/CliError.ts
+var CliError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = new.target.name;
+	}
+};
+//#endregion
+//#region src/ExitCode.ts
+const ExitCode = {
+	success: 0,
+	problemsFound: 1,
+	couldNotRun: 2
+};
+//#endregion
+//#region src/Invocation.ts
+const nonEmptyVariable = (invocation, name) => invocation.environmentVariables[name] || void 0;
+//#endregion
+//#region src/admin-api/admin-api-errors.ts
+const ApiAuthorizationErrorBodySchema = v.object({
+	error: v.string(),
+	code: v.string()
+});
+const ApiValidationErrorBodySchema = v.object({ errors: v.array(v.object({
+	name: v.optional(v.string()),
+	message: v.string()
+})) });
+const ServiceSuspendedBodySchema = v.object({ code: v.literal("SERVICE_SUSPENDED") });
+const describeFieldError = (fieldError) => fieldError.name === void 0 ? fieldError.message : `${fieldError.name}: ${fieldError.message}`;
+var ApiAuthorizationError = class extends CliError {
+	constructor(code, apiMessage) {
+		super(`The Admin API refused the request: ${apiMessage} (${code})`);
+	}
+};
+var ApiValidationError = class extends CliError {
+	constructor(errors) {
+		super(`The Admin API rejected the request:\n${errors.map((error) => `  ${describeFieldError(error)}`).join("\n")}`);
+	}
+};
+var ServiceSuspendedError = class extends CliError {
+	constructor(retryAfterSeconds) {
+		super(`Your organization's service is suspended, so ConfigDirector refuses Admin API requests. The dashboard's billing page shows why and how to reinstate it. Retry after ${retryAfterSeconds} seconds.`);
+	}
+};
+var ApiUnreachableError = class extends CliError {
+	constructor(baseUrl, cause) {
+		const reason = cause instanceof Error && cause.cause instanceof Error ? cause.cause.message : String(cause);
+		super(`Could not reach the Admin API at ${baseUrl} (${reason}). Check the network connection, --base-url or CONFIGDIRECTOR_BASE_URL.`);
+	}
+};
+var UnexpectedApiResponseError = class extends CliError {
+	constructor(url, description) {
+		super(`The Admin API answered ${url} with ${description}.`);
+	}
+};
+//#endregion
+//#region src/admin-api/AdminApiClient.ts
+const ProjectSchema = v.object({
+	id: v.string(),
+	name: v.string(),
+	slug: v.string()
+});
+const configFields = {
+	key: v.string(),
+	deprecatedKeys: v.array(v.object({ key: v.string() })),
+	client: v.boolean(),
+	server: v.boolean()
+};
+const EnumConfigSchema = v.object({
+	...configFields,
+	type: v.literal("enum"),
+	typeOptions: v.object({
+		valueType: v.string(),
+		values: v.array(v.string())
+	})
+});
+const ConfigSchema = v.variant("type", [EnumConfigSchema, v.object({
+	...configFields,
+	type: v.pipe(v.string(), v.notValue("enum"))
+})]);
+const isEnumConfig = (config) => config.type === "enum";
+const readJsonBody = async (response) => {
+	try {
+		return await response.json();
+	} catch {
+		return;
+	}
+};
+const describeStatus = (response) => `HTTP ${response.status}`;
+const failureFor = (url, response, body) => {
+	switch (response.status) {
+		case 400: {
+			const validationError = v.safeParse(ApiValidationErrorBodySchema, body);
+			return validationError.success ? new ApiValidationError(validationError.output.errors) : new UnexpectedApiResponseError(url, describeStatus(response));
+		}
+		case 403: {
+			const authorizationError = v.safeParse(ApiAuthorizationErrorBodySchema, body);
+			return authorizationError.success ? new ApiAuthorizationError(authorizationError.output.code, authorizationError.output.error) : new UnexpectedApiResponseError(url, describeStatus(response));
+		}
+		case 429: {
+			const retryAfterSeconds = response.headers.get("retry-after");
+			return v.is(ServiceSuspendedBodySchema, body) && retryAfterSeconds !== null ? new ServiceSuspendedError(retryAfterSeconds) : new UnexpectedApiResponseError(url, describeStatus(response));
+		}
+		default: return new UnexpectedApiResponseError(url, describeStatus(response));
+	}
+};
+var AdminApiClient = class {
+	constructor(connection) {
+		this.connection = connection;
+	}
+	listProjects() {
+		return this.get("/v1/projects", v.array(ProjectSchema));
+	}
+	listConfigs(projectId) {
+		return this.get(`/v1/projects/${encodeURIComponent(projectId)}/configs`, v.array(ConfigSchema));
+	}
+	async get(path, schema) {
+		const url = `${this.connection.baseUrl}${path}`;
+		const response = await this.fetchResponse(url);
+		const body = await readJsonBody(response);
+		if (!response.ok) throw failureFor(url, response, body);
+		const parsedBody = v.safeParse(schema, body);
+		if (!parsedBody.success) throw new UnexpectedApiResponseError(url, `an ${describeStatus(response)} response the CLI cannot read`);
+		return parsedBody.output;
+	}
+	async fetchResponse(url) {
+		try {
+			return await fetch(url, { headers: {
+				Accept: "application/json",
+				Authorization: `Bearer ${this.connection.token}`,
+				"User-Agent": `configdirector-cli/${version}`,
+				"X-SourceClient": "cli"
+			} });
+		} catch (error) {
+			throw new ApiUnreachableError(this.connection.baseUrl, error);
+		}
+	}
+};
+//#endregion
+//#region src/file-contents.ts
+const readFileIfPresent = async (file) => {
+	try {
+		return await readFile(file, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw error;
+	}
+};
+const parseJson = (contents) => {
+	try {
+		return JSON.parse(contents);
+	} catch {
+		return;
+	}
+};
+const pathExists = (path) => stat(path).then(() => true, () => false);
+const fileExists = (path) => stat(path).then((stats) => stats.isFile(), () => false);
+//#endregion
+//#region src/saved-api-token.ts
+const SavedApiTokenSchema = v.object({ token: v.string() });
+const platformConfigDirectory = (invocation) => {
+	switch (invocation.platform) {
+		case "darwin": return join(invocation.homeDirectory, "Library", "Application Support");
+		case "win32": return nonEmptyVariable(invocation, "APPDATA") ?? join(invocation.homeDirectory, "AppData", "Roaming");
+		default: return join(invocation.homeDirectory, ".config");
+	}
+};
+const userConfigDirectory = (invocation) => nonEmptyVariable(invocation, "XDG_CONFIG_HOME") ?? platformConfigDirectory(invocation);
+const savedApiTokenFile = (invocation) => join(userConfigDirectory(invocation), "configdirector", "config.json");
+const readSavedApiToken = async (invocation) => {
+	const file = savedApiTokenFile(invocation);
+	const contents = await readFileIfPresent(file);
+	if (contents === void 0) return;
+	const savedToken = v.safeParse(SavedApiTokenSchema, parseJson(contents));
+	if (!savedToken.success) throw new CliError(`${file} does not hold a saved API token. Run \`configdirector login\` again.`);
+	return savedToken.output.token;
+};
+const saveApiToken = async (invocation, token) => {
+	const file = savedApiTokenFile(invocation);
+	await mkdir(dirname(file), {
+		recursive: true,
+		mode: 448
+	});
+	const handle = await open(file, "w", 384);
+	try {
+		await handle.chmod(384);
+		await handle.writeFile(`${JSON.stringify({ token }, null, 2)}\n`);
+	} finally {
+		await handle.close();
+	}
+	return file;
+};
+//#endregion
+//#region src/configured-api-token.ts
+const configuredApiToken = async (context) => {
+	const token = context.tokenOption ?? nonEmptyVariable(context.invocation, "CONFIGDIRECTOR_TOKEN") ?? await readSavedApiToken(context.invocation);
+	if (!token) throw new CliError("No API token found. Set CONFIGDIRECTOR_TOKEN, pass --token, or run `configdirector login`.");
+	return token;
+};
+//#endregion
+//#region src/project-selection.ts
+const requireProjectSlug = (context) => {
+	if (context.projectSlug === void 0) throw new CliError("Name the project with --project <slug> or CONFIGDIRECTOR_PROJECT.");
+	return context.projectSlug;
+};
+const requireLinkedProjectSlug = (context, settings) => {
+	const slug = context.projectSlug ?? settings?.project;
+	if (slug === void 0) throw new CliError("Name the project with --project <slug>, CONFIGDIRECTOR_PROJECT, or `project` in configdirector.json, which `configdirector init` writes.");
+	return slug;
+};
+const findProjectBySlug = async (client, slug) => {
+	const project = (await client.listProjects()).find((listedProject) => listedProject.slug === slug);
+	if (project === void 0) throw new CliError(`No project in the API token's organization has the slug "${slug}".`);
+	return project;
+};
+//#endregion
+//#region src/project-settings.ts
+const ProjectSettingsSchema = v.object({
+	project: v.optional(v.string()),
+	include: v.optional(v.array(v.string())),
+	exclude: v.optional(v.array(v.string())),
+	ignoreKeys: v.optional(v.array(v.string()))
+});
+const projectSettingsFile = (workingDirectory) => join(workingDirectory, "configdirector.json");
+const describeIssue = (issue) => {
+	const path = v.getDotPath(issue);
+	return path === null ? issue.message : `${path}: ${issue.message}`;
+};
+const readProjectSettings = async (workingDirectory) => {
+	const file = projectSettingsFile(workingDirectory);
+	const contents = await readFileIfPresent(file);
+	if (contents === void 0) return;
+	const settings = v.safeParse(ProjectSettingsSchema, parseJson(contents));
+	if (!settings.success) throw new CliError(`${file} is not valid (${settings.issues.map(describeIssue).join("; ")}).`);
+	return settings.output;
+};
+//#endregion
+//#region src/commands/init.ts
+const refuseExistingFile = async (file) => {
+	if (await access(file).then(() => true, () => false)) throw new CliError(`${file} already exists. init never overwrites it; edit the file instead.`);
+};
+const init = async (context) => {
+	const settingsFile = projectSettingsFile(context.invocation.workingDirectory);
+	await refuseExistingFile(settingsFile);
+	const projectSlug = requireProjectSlug(context);
+	const project = await findProjectBySlug(new AdminApiClient({
+		baseUrl: context.baseUrl,
+		token: await configuredApiToken(context)
+	}), projectSlug);
+	const settings = {
+		project: project.slug,
+		include: ["**"],
+		exclude: [],
+		ignoreKeys: []
+	};
+	await writeFile(settingsFile, `${JSON.stringify(settings, null, 2)}\n`, { flag: "wx" });
+	return {
+		json: {
+			settingsFile,
+			project: {
+				id: project.id,
+				slug: project.slug,
+				name: project.name
+			}
+		},
+		text: `Linked this directory to the project ${project.name} (${project.slug}) in ${settingsFile}\n`,
+		exitCode: ExitCode.success
+	};
+};
+//#endregion
+//#region src/pasted-api-token.ts
+const Key = {
+	carriageReturn: "\r",
+	lineFeed: "\n",
+	interrupt: "",
+	delete: "",
+	backspace: "\b"
+};
+const isTerminal = (input) => input.isTTY === true && typeof input.setRawMode === "function";
+const readLine = async (input) => {
+	const lines = createInterface({
+		input,
+		crlfDelay: Infinity
+	});
+	for await (const line of lines) return line;
+	return "";
+};
+const readLineWithoutEcho = (input, output) => new Promise((resolve, reject) => {
+	let typedCharacters = "";
+	const endHiddenInput = () => {
+		input.off("data", onData);
+		input.setRawMode(false);
+		input.pause();
+		output.write("\n");
+	};
+	const onData = (chunk) => {
+		for (const character of chunk.toString()) switch (character) {
+			case Key.carriageReturn:
+			case Key.lineFeed:
+				endHiddenInput();
+				resolve(typedCharacters);
+				return;
+			case Key.interrupt:
+				endHiddenInput();
+				reject(new CliError("Login canceled."));
+				return;
+			case Key.delete:
+			case Key.backspace:
+				typedCharacters = typedCharacters.slice(0, -1);
+				break;
+			default: typedCharacters += character;
+		}
+	};
+	input.setRawMode(true);
+	input.on("data", onData);
+	input.resume();
+});
+const readPastedApiToken = async (invocation) => {
+	invocation.stderr.write("Paste your API token: ");
+	const { stdin } = invocation;
+	const token = (isTerminal(stdin) ? await readLineWithoutEcho(stdin, invocation.stderr) : await readLine(stdin)).trim();
+	if (token === "") throw new CliError("No API token was pasted.");
+	return token;
+};
+//#endregion
+//#region src/commands/login.ts
+const login = async (context) => {
+	const token = context.tokenOption ?? await readPastedApiToken(context.invocation);
+	await new AdminApiClient({
+		baseUrl: context.baseUrl,
+		token
+	}).listProjects();
+	const file = await saveApiToken(context.invocation, token);
+	return {
+		json: { tokenFile: file },
+		text: `Logged in. The API token is saved in ${file}\n`,
+		exitCode: ExitCode.success
+	};
+};
+//#endregion
+//#region src/plural.ts
+const plural = (count, singular, pluralForm) => count === 1 ? singular : pluralForm;
+//#endregion
+//#region src/scan/source-languages.ts
+const languageOfExtension = {
+	".js": "javascript",
+	".jsx": "javascript",
+	".mjs": "javascript",
+	".cjs": "javascript",
+	".ts": "javascript",
+	".tsx": "javascript",
+	".mts": "javascript",
+	".cts": "javascript",
+	".vue": "javascript",
+	".svelte": "javascript",
+	".dart": "dart",
+	".swift": "swift",
+	".kt": "kotlin",
+	".java": "java",
+	".py": "python",
+	".cs": "csharp",
+	".go": "go"
+};
+const isSourceExtension = (extension) => Object.hasOwn(languageOfExtension, extension);
+const languageSyntax = {
+	javascript: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	dart: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	swift: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	kotlin: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	java: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	python: {
+		lineComment: "#",
+		blockComments: false,
+		angleBracketGenerics: false
+	},
+	csharp: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: true
+	},
+	go: {
+		lineComment: "//",
+		blockComments: true,
+		angleBracketGenerics: false
+	}
+};
+//#endregion
+//#region src/scan/source-code.ts
+const closerOfOpener = {
+	"(": ")",
+	"[": "]",
+	"{": "}"
+};
+const closers = new Set(Object.values(closerOfOpener));
+const quotes = new Set([
+	"\"",
+	"'",
+	"`"
+]);
+const OPENERS_SEARCHED_FOR_A_CLOSER = 8;
+const isAsciiLetter = (character) => character >= "a" && character <= "z" || character >= "A" && character <= "Z";
+const isDigit = (character) => character >= "0" && character <= "9";
+const isIdentifierStart = (character) => isAsciiLetter(character) || character === "_" || character === "$" || character > "";
+const isIdentifierPart = (character) => isIdentifierStart(character) || isDigit(character);
+const isWhitespace = (character) => character === " " || character === "	" || character === "\n" || character === "\r" || character === "\f";
+const endOfLine = (source, start) => {
+	const newline = source.indexOf("\n", start);
+	return newline === -1 ? source.length : newline;
+};
+const endOfComment = (source, start, syntax) => {
+	if (source.startsWith(syntax.lineComment, start)) return endOfLine(source, start);
+	if (syntax.blockComments && source.startsWith("/*", start)) {
+		const close = source.indexOf("*/", start + 2);
+		return close === -1 ? source.length : close + 2;
+	}
+};
+const endOfStringLiteral = (source, start) => {
+	const quote = source.charAt(start);
+	const tripleQuote = quote.repeat(3);
+	if (quote !== "`" && source.startsWith(tripleQuote, start)) {
+		const close = source.indexOf(tripleQuote, start + 3);
+		return close === -1 ? source.length : close + 3;
+	}
+	let index = start + 1;
+	while (index < source.length) {
+		const character = source.charAt(index);
+		if (character === "\\") index += 2;
+		else if (character === quote) return index + 1;
+		else if (character === "\n" && quote !== "`") return index;
+		else index += 1;
+	}
+	return source.length;
+};
+const endOfCharactersWhere = (source, start, belongs) => {
+	let index = start;
+	while (index < source.length && belongs(index)) index += 1;
+	return index;
+};
+const endOfNumber = (source, start) => endOfCharactersWhere(source, start, (index) => isIdentifierPart(source.charAt(index)) || source.charAt(index) === "." && isDigit(source.charAt(index + 1)));
+const tokenize = (source, syntax) => {
+	const tokens = [];
+	const push = (kind, start, end) => tokens.push({
+		kind,
+		text: source.slice(start, end),
+		start,
+		end
+	});
+	let index = 0;
+	while (index < source.length) {
+		const character = source.charAt(index);
+		const commentEnd = endOfComment(source, index, syntax);
+		let end;
+		if (isWhitespace(character)) end = index + 1;
+		else if (commentEnd !== void 0) end = commentEnd;
+		else if (quotes.has(character)) {
+			end = endOfStringLiteral(source, index);
+			push("string", index, end);
+		} else if (isIdentifierStart(character)) {
+			end = endOfCharactersWhere(source, index, (position) => isIdentifierPart(source.charAt(position)));
+			push("identifier", index, end);
+		} else if (isDigit(character)) {
+			end = endOfNumber(source, index);
+			push("number", index, end);
+		} else {
+			end = index + 1;
+			push("punctuation", index, end);
+		}
+		index = end;
+	}
+	return tokens;
+};
+const matchedGroups = (tokens) => {
+	const closerIndex = new Int32Array(tokens.length).fill(-1);
+	const openerIndex = new Int32Array(tokens.length).fill(-1);
+	const openOpeners = [];
+	tokens.forEach((token, index) => {
+		if (token.kind !== "punctuation") return;
+		if (Object.hasOwn(closerOfOpener, token.text)) {
+			openOpeners.push(index);
+			return;
+		}
+		if (!closers.has(token.text)) return;
+		const lowestSearched = Math.max(0, openOpeners.length - OPENERS_SEARCHED_FOR_A_CLOSER);
+		for (let position = openOpeners.length - 1; position >= lowestSearched; position -= 1) {
+			const opener = openOpeners[position];
+			if (closerOfOpener[tokens[opener].text] === token.text) {
+				closerIndex[opener] = index;
+				openerIndex[index] = opener;
+				openOpeners.length = position;
+				return;
+			}
+		}
+	});
+	return {
+		closerIndex,
+		openerIndex
+	};
+};
+var SourceCode = class {
+	tokens;
+	syntax;
+	groups;
+	lineStarts;
+	constructor(source, language) {
+		this.source = source;
+		this.language = language;
+		this.syntax = languageSyntax[language];
+		this.tokens = tokenize(source, this.syntax);
+		this.groups = matchedGroups(this.tokens);
+	}
+	token(index) {
+		return this.tokens[index];
+	}
+	isPunctuation(index, text) {
+		const token = this.tokens[index];
+		return token?.kind === "punctuation" && token.text === text;
+	}
+	isIdentifier(index, text) {
+		const token = this.tokens[index];
+		return token?.kind === "identifier" && token.text === text;
+	}
+	openerOfLastToken(range, closer) {
+		const opener = this.groups.openerIndex[range.last] ?? -1;
+		return this.isPunctuation(range.last, closer) && opener >= range.first ? opener : void 0;
+	}
+	firstTopLevelIndex(range, isWanted) {
+		let index = range.first;
+		while (index <= range.last) {
+			if (isWanted(index)) return index;
+			index = (this.closerOf(index) ?? index) + 1;
+		}
+	}
+	closerOf(openerIndex) {
+		const closer = this.groups.closerIndex[openerIndex] ?? -1;
+		return closer === -1 ? void 0 : closer;
+	}
+	textOf(range) {
+		const first = this.tokens[range.first];
+		const last = this.tokens[range.last];
+		return this.source.slice(first.start, last.end);
+	}
+	commaSeparatedItems(openerIndex) {
+		const closer = this.closerOf(openerIndex);
+		if (closer === void 0) return;
+		const items = [];
+		let itemStart = openerIndex + 1;
+		let angleBracketDepth = 0;
+		let index = openerIndex + 1;
+		while (index < closer) {
+			const token = this.tokens[index];
+			if (token.kind === "punctuation") {
+				if (token.text === "," && angleBracketDepth === 0) {
+					items.push({
+						first: itemStart,
+						last: index - 1
+					});
+					itemStart = index + 1;
+				} else if (this.opensTypeArguments(index)) angleBracketDepth += 1;
+				else if (token.text === ">" && angleBracketDepth > 0) angleBracketDepth -= 1;
+			}
+			index = (this.closerOf(index) ?? index) + 1;
+		}
+		if (itemStart < closer) items.push({
+			first: itemStart,
+			last: closer - 1
+		});
+		return items;
+	}
+	lineOf(tokenIndex) {
+		const offset = this.tokens[tokenIndex].start;
+		const lineStarts = this.knownLineStarts();
+		let low = 0;
+		let high = lineStarts.length - 1;
+		while (low < high) {
+			const middle = Math.ceil((low + high) / 2);
+			if (lineStarts[middle] <= offset) low = middle;
+			else high = middle - 1;
+		}
+		return low + 1;
+	}
+	startsLine(tokenIndex) {
+		const token = this.tokens[tokenIndex];
+		const previous = this.tokens[tokenIndex - 1];
+		return token !== void 0 && (previous === void 0 || this.source.slice(previous.end, token.start).includes("\n"));
+	}
+	characterAfter(tokenIndex) {
+		const token = this.tokens[tokenIndex];
+		return token === void 0 ? "" : this.source.charAt(token.end);
+	}
+	opensTypeArguments(index) {
+		const previous = this.tokens[index - 1];
+		const current = this.tokens[index];
+		return this.syntax.angleBracketGenerics && current?.kind === "punctuation" && current.text === "<" && previous?.kind === "identifier" && previous.end === current.start;
+	}
+	knownLineStarts() {
+		if (this.lineStarts === void 0) {
+			const lineStarts = [0];
+			for (let index = 0; index < this.source.length; index += 1) if (this.source.charAt(index) === "\n") lineStarts.push(index + 1);
+			this.lineStarts = lineStarts;
+		}
+		return this.lineStarts;
+	}
+};
+//#endregion
+//#region src/scan/literals.ts
+const MINIMUM_KEY_LENGTH = 4;
+const MAXIMUM_KEY_LENGTH = 150;
+const NUMBER_LITERAL = /^-?\d[\d_]*(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?[fFdDmMlL]?$/;
+const FLOAT_MARKERS = [
+	".",
+	"e",
+	"E",
+	"f",
+	"F",
+	"d",
+	"D",
+	"m",
+	"M"
+];
+const isAlphanumeric = (character) => isDigit(character) || isAsciiLetter(character);
+const isKeyCharacter = (character) => isAlphanumeric(character) || character === "." || character === "_" || character === "-";
+const fitsKeyGrammar = (text) => text.length >= MINIMUM_KEY_LENGTH && text.length <= MAXIMUM_KEY_LENGTH && isAlphanumeric(text.charAt(0)) && [...text].every(isKeyCharacter);
+const singleToken = (code, range) => range.first === range.last ? code.token(range.first) : void 0;
+const plainStringContent = (code, range) => {
+	const token = singleToken(code, range);
+	if (token?.kind !== "string" || token.text.length < 2) return;
+	const quote = token.text.charAt(0);
+	const content = token.text.slice(1, -1);
+	return token.text.endsWith(quote) && !content.includes(quote) && !content.includes("\\") && !content.includes("$") ? content : void 0;
+};
+const literalTextOf = (code, expression) => expression.isName ? code.textOf(expression.range) : plainStringContent(code, expression.range);
+const keyLiteralOf = (code, expression) => {
+	const content = literalTextOf(code, expression);
+	if (content === void 0) return { kind: "notLiteral" };
+	return fitsKeyGrammar(content) ? {
+		kind: "key",
+		key: content
+	} : { kind: "outsideKeyGrammar" };
+};
+const isLiteralGroup = (code, range) => (code.isPunctuation(range.first, "{") || code.isPunctuation(range.first, "[")) && code.closerOf(range.first) === range.last;
+const numberLiteralOf = (text) => {
+	if (!NUMBER_LITERAL.test(text)) return;
+	const value = Number(text.replace(/[_fFdDmMlL]/g, ""));
+	if (!Number.isFinite(value)) return;
+	return FLOAT_MARKERS.some((marker) => text.includes(marker)) ? {
+		type: "float",
+		value
+	} : {
+		type: "integer",
+		value
+	};
+};
+const inCodeDefaultValueOf = (code, range) => {
+	const text = code.textOf(range);
+	if (text === "true" || text === "True") return {
+		type: "boolean",
+		value: true
+	};
+	if (text === "false" || text === "False") return {
+		type: "boolean",
+		value: false
+	};
+	const stringContent = plainStringContent(code, range);
+	if (stringContent !== void 0) return {
+		type: "string",
+		value: stringContent
+	};
+	if (isLiteralGroup(code, range)) return {
+		type: "json",
+		value: text
+	};
+	return numberLiteralOf(text);
+};
+//#endregion
+//#region src/scan/constant-index.ts
+const TOKENS_ENDING_AN_ASSIGNED_LITERAL = new Set([
+	";",
+	",",
+	")",
+	"}",
+	"]"
+]);
+const endsAssignedLiteral = (code, stringIndex) => {
+	const next = code.token(stringIndex + 1);
+	return next === void 0 || next.kind === "punctuation" && TOKENS_ENDING_AN_ASSIGNED_LITERAL.has(next.text) || code.isIdentifier(stringIndex + 1, "as") || code.startsLine(stringIndex + 1);
+};
+const identifierAt = (code, index) => {
+	const token = code.token(index);
+	return token?.kind === "identifier" ? token.text : void 0;
+};
+const nameAssignedAt = (code, equalsIndex) => {
+	const nameOrType = identifierAt(code, equalsIndex - 1);
+	if (nameOrType !== void 0) return (code.isPunctuation(equalsIndex - 2, ":") ? identifierAt(code, equalsIndex - 3) : void 0) ?? nameOrType;
+	return code.isPunctuation(equalsIndex - 1, ":") && code.characterAfter(equalsIndex - 1) === "=" ? identifierAt(code, equalsIndex - 2) : void 0;
+};
+const nameHoldingLiteralAt = (code, stringIndex) => {
+	if (code.isPunctuation(stringIndex - 1, "=")) return nameAssignedAt(code, stringIndex - 1);
+	return code.isPunctuation(stringIndex - 1, ":") ? identifierAt(code, stringIndex - 2) : void 0;
+};
+const constantAssignmentsIn = (code) => code.tokens.flatMap((token, index) => {
+	if (token.kind !== "string" || !endsAssignedLiteral(code, index)) return [];
+	const key = plainStringContent(code, {
+		first: index,
+		last: index
+	});
+	if (key === void 0 || !fitsKeyGrammar(key)) return [];
+	const name = nameHoldingLiteralAt(code, index);
+	return name === void 0 ? [] : [{
+		name,
+		key,
+		tokenIndex: index
+	}];
+});
+var ConstantIndex = class {
+	keyOfName = /* @__PURE__ */ new Map();
+	add(assignment) {
+		const indexed = this.keyOfName.get(assignment.name);
+		if (indexed === void 0) this.keyOfName.set(assignment.name, {
+			kind: "key",
+			key: assignment.key
+		});
+		else if (indexed.kind === "key" && indexed.key !== assignment.key) this.keyOfName.set(assignment.name, { kind: "ambiguous" });
+	}
+	keyOf(name) {
+		const indexed = this.keyOfName.get(name);
+		return indexed?.kind === "key" ? indexed.key : void 0;
+	}
+};
+//#endregion
+//#region src/scan/known-key-texts.ts
+const knownKeyTextsIn = (code, projectKeys, tokensReadByCalls) => code.tokens.flatMap((token, index) => {
+	if (token.kind !== "string" || tokensReadByCalls.has(index)) return [];
+	const content = plainStringContent(code, {
+		first: index,
+		last: index
+	});
+	return content !== void 0 && projectKeys.has(content) ? [{
+		tokenIndex: index,
+		key: content
+	}] : [];
+});
+//#endregion
+//#region src/scan/nearest-declarations.ts
+var NearestDeclarations = class {
+	declarationOfDirectory = /* @__PURE__ */ new Map();
+	constructor(highestDirectory, declaredIn) {
+		this.highestDirectory = highestDirectory;
+		this.declaredIn = declaredIn;
+	}
+	declarationAbove(file) {
+		return this.declarationAtOrAbove(dirname(file));
+	}
+	declarationAtOrAbove(directory) {
+		const declarationLookedUpBefore = this.declarationOfDirectory.get(directory);
+		if (declarationLookedUpBefore !== void 0) return declarationLookedUpBefore;
+		const parent = dirname(directory);
+		const isLastSearched = directory === this.highestDirectory || parent === directory;
+		const declaration = this.declaredIn(directory).then((declarationHere) => declarationHere ?? (isLastSearched ? void 0 : this.declarationAtOrAbove(parent)));
+		this.declarationOfDirectory.set(directory, declaration);
+		return declaration;
+	}
+};
+//#endregion
+//#region src/scan/scanned-files.ts
+const EXCLUDED_DIRECTORY_NAMES = new Set([
+	".git",
+	"node_modules",
+	"vendor",
+	"build",
+	"dist",
+	"target"
+]);
+const MAXIMUM_FILE_BYTES = 1024 * 1024;
+const BYTES_CHECKED_FOR_BINARY_CONTENT = 8e3;
+const slashSeparated = (path) => path.split(sep).join("/");
+const isInside = (directory, path) => {
+	const pathFromDirectory = relative(directory, path);
+	return pathFromDirectory !== "" && !pathFromDirectory.startsWith("..") && !isAbsolute(pathFromDirectory);
+};
+const scanRootAt = async (workingDirectory, path) => {
+	const rootPath = resolve(workingDirectory, path ?? ".");
+	let rootStats;
+	try {
+		rootStats = await stat(rootPath);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new CliError(`There is no file or directory at ${path} to scan.`);
+		throw error;
+	}
+	return {
+		path: rootPath,
+		isDirectory: rootStats.isDirectory(),
+		description: path ?? "the current directory"
+	};
+};
+const gitignoreRulesIn = async (directory) => {
+	const contents = await readFileIfPresent(join(directory, ".gitignore"));
+	return contents === void 0 ? [] : [{
+		directory,
+		rules: ignore().add(contents)
+	}];
+};
+const gitRepositoryRootAbove = async (path) => {
+	for (let directory = path;; directory = dirname(directory)) {
+		if (await pathExists(join(directory, ".git"))) return directory;
+		if (dirname(directory) === directory) return;
+	}
+};
+const ancestorDirectoriesBelow = (highestDirectory, path) => {
+	const ancestors = [];
+	for (let directory = dirname(path); isInside(highestDirectory, directory); directory = dirname(directory)) ancestors.unshift(directory);
+	return isInside(highestDirectory, path) ? [highestDirectory, ...ancestors] : [];
+};
+const isGitignored = (path, isDirectory, rulesInScope) => {
+	for (const { directory, rules } of [...rulesInScope].reverse()) {
+		if (!isInside(directory, path)) continue;
+		const pathFromDirectory = slashSeparated(relative(directory, path));
+		const result = rules.test(isDirectory ? `${pathFromDirectory}/` : pathFromDirectory);
+		if (result.ignored || result.unignored) return result.ignored;
+	}
+	return false;
+};
+const readFileWithinSizeLimit = async (path) => {
+	const stats = await stat(path).catch(() => void 0);
+	return stats?.isFile() && stats.size <= MAXIMUM_FILE_BYTES ? readFile(path, "utf8") : void 0;
+};
+const hasBinaryContent = (contents) => contents.subarray(0, BYTES_CHECKED_FOR_BINARY_CONTENT).includes(0);
+async function* candidateFiles(directory, rulesInScope) {
+	const rulesHere = [...rulesInScope, ...await gitignoreRulesIn(directory)];
+	const entries = await readdir(directory, { withFileTypes: true });
+	for (const entry of entries.sort((first, second) => first.name < second.name ? -1 : 1)) {
+		const path = join(directory, entry.name);
+		if (entry.isDirectory()) {
+			if (!EXCLUDED_DIRECTORY_NAMES.has(entry.name) && !isGitignored(path, true, rulesHere)) yield* candidateFiles(path, rulesHere);
+		} else if (entry.isFile() && !isGitignored(path, false, rulesHere)) yield path;
+	}
+}
+async function* scannedFiles(scope) {
+	const isIncluded = scope.include === "everyFile" ? () => true : picomatch([...scope.include], { dot: true });
+	const isExcluded = picomatch([...scope.exclude], { dot: true });
+	const highestGitignoreDirectory = await gitRepositoryRootAbove(scope.root.path) ?? scope.workingDirectory;
+	const ancestorRules = (await Promise.all(ancestorDirectoriesBelow(highestGitignoreDirectory, scope.root.path).map(gitignoreRulesIn))).flat();
+	const candidates = scope.root.isDirectory ? candidateFiles(scope.root.path, ancestorRules) : (async function* () {
+		if (!isGitignored(scope.root.path, false, ancestorRules)) yield scope.root.path;
+	})();
+	for await (const path of candidates) {
+		const extension = extname(path);
+		const displayPath = slashSeparated(relative(scope.workingDirectory, path));
+		if (!isSourceExtension(extension) || !isIncluded(displayPath) || isExcluded(displayPath)) continue;
+		if ((await stat(path)).size > MAXIMUM_FILE_BYTES) continue;
+		const contents = await readFile(path);
+		if (!hasBinaryContent(contents)) yield {
+			path,
+			displayPath,
+			extension,
+			contents: contents.toString("utf8")
+		};
+	}
+}
+//#endregion
+//#region src/scan/path-aliases.ts
+const WILDCARD = "*";
+const EXACT_MATCH_RANK = Number.POSITIVE_INFINITY;
+const JSON_EXTENSION = ".json";
+const BYTE_ORDER_MARK = "";
+const TYPESCRIPT_CONFIG_FILE = "tsconfig.json";
+const CONFIG_FILE_NAMES = [TYPESCRIPT_CONFIG_FILE, "jsconfig.json"];
+const NO_ALIAS_OPTIONS = {
+	paths: void 0,
+	baseUrl: void 0
+};
+const TypeScriptConfigSchema = v.object({
+	extends: v.optional(v.union([v.string(), v.array(v.string())])),
+	compilerOptions: v.optional(v.object({
+		baseUrl: v.optional(v.string()),
+		paths: v.optional(v.record(v.string(), v.array(v.string())))
+	})),
+	references: v.optional(v.array(v.object({ path: v.string() })))
+});
+const pathPatternsOf = (targetsOfPattern) => Object.entries(targetsOfPattern).flatMap(([key, targets]) => {
+	const wildcard = key.indexOf(WILDCARD);
+	if (wildcard === -1) return [{
+		kind: "exact",
+		key,
+		targets
+	}];
+	return key.includes(WILDCARD, wildcard + 1) ? [] : [{
+		kind: "wildcard",
+		prefix: key.slice(0, wildcard),
+		suffix: key.slice(wildcard + 1),
+		targets
+	}];
+});
+const aliasMatchOf = (pattern, specifier) => {
+	switch (pattern.kind) {
+		case "exact": return specifier === pattern.key ? {
+			rank: EXACT_MATCH_RANK,
+			targets: pattern.targets
+		} : void 0;
+		case "wildcard": {
+			const fits = specifier.length >= pattern.prefix.length + pattern.suffix.length && specifier.startsWith(pattern.prefix) && specifier.endsWith(pattern.suffix);
+			const wildcardText = specifier.slice(pattern.prefix.length, specifier.length - pattern.suffix.length);
+			return fits ? {
+				rank: pattern.prefix.length,
+				targets: pattern.targets.map((target) => target.replace(WILDCARD, () => wildcardText))
+			} : void 0;
+		}
+	}
+};
+const bestAliasMatch = (patterns, specifier) => patterns.reduce((best, pattern) => {
+	const match = aliasMatchOf(pattern, specifier);
+	return match !== void 0 && (best === void 0 || match.rank > best.rank) ? match : best;
+}, void 0);
+const mappedModulePaths = (pathMapping, specifier) => bestAliasMatch(pathMapping.patterns, specifier)?.targets.map((target) => resolve(pathMapping.targetDirectory, target));
+const modulePathsIn = ({ pathMapping, baseUrl }, specifier) => {
+	const mappedPaths = pathMapping === void 0 ? void 0 : mappedModulePaths(pathMapping, specifier);
+	if (mappedPaths !== void 0) return mappedPaths;
+	return baseUrl === void 0 ? [] : [resolve(baseUrl, specifier)];
+};
+const isTrailingComma = (code, index) => code.isPunctuation(index, ",") && (code.isPunctuation(index + 1, "}") || code.isPunctuation(index + 1, "]"));
+const jsonOfConfigFile = (contents) => {
+	const code = new SourceCode(contents.startsWith(BYTE_ORDER_MARK) ? contents.slice(1) : contents, "javascript");
+	return code.tokens.map((token, index) => {
+		return " ".repeat(token.start - (code.token(index - 1)?.end ?? 0)) + (isTrailingComma(code, index) ? " " : token.text);
+	}).join("");
+};
+const isRelativeConfigPath = (path) => path.startsWith("./") || path.startsWith("../");
+const extendedConfigFileAt = async (path) => await fileExists(path) || path.endsWith(JSON_EXTENSION) ? path : `${path}${JSON_EXTENSION}`;
+const referencedConfigFileAt = (path) => path.endsWith(JSON_EXTENSION) ? path : join(path, TYPESCRIPT_CONFIG_FILE);
+const typeScriptConfigAt = async (configFile) => {
+	const contents = await readFileWithinSizeLimit(configFile);
+	const config = v.safeParse(TypeScriptConfigSchema, contents === void 0 ? void 0 : parseJson(jsonOfConfigFile(contents)));
+	if (!config.success) return {
+		aliasOptions: NO_ALIAS_OPTIONS,
+		extendedConfigFiles: [],
+		referencedConfigFiles: []
+	};
+	const { compilerOptions, extends: extendedConfigs, references } = config.output;
+	const configDirectory = dirname(configFile);
+	const relativeExtendedConfigs = [extendedConfigs ?? []].flat().filter(isRelativeConfigPath);
+	return {
+		aliasOptions: {
+			paths: compilerOptions?.paths === void 0 ? void 0 : {
+				targetsOfPattern: compilerOptions.paths,
+				configDirectory
+			},
+			baseUrl: compilerOptions?.baseUrl === void 0 ? void 0 : resolve(configDirectory, compilerOptions.baseUrl)
+		},
+		extendedConfigFiles: await Promise.all(relativeExtendedConfigs.map((extendedConfig) => extendedConfigFileAt(resolve(configDirectory, extendedConfig)))),
+		referencedConfigFiles: (references ?? []).map((reference) => referencedConfigFileAt(resolve(configDirectory, reference.path)))
+	};
+};
+const ownOrInherited = (own, inherited) => ({
+	paths: own.paths ?? inherited.paths,
+	baseUrl: own.baseUrl ?? inherited.baseUrl
+});
+const declaresAliases = (aliasOptions) => aliasOptions.paths !== void 0 || aliasOptions.baseUrl !== void 0;
+const aliasRulesOf = ({ paths, baseUrl }) => ({
+	pathMapping: paths === void 0 ? void 0 : {
+		patterns: pathPatternsOf(paths.targetsOfPattern),
+		targetDirectory: baseUrl ?? paths.configDirectory
+	},
+	baseUrl
+});
+var TypeScriptConfigs = class {
+	configOfFile = /* @__PURE__ */ new Map();
+	aliasOptionsOfFile = /* @__PURE__ */ new Map();
+	configAt(configFile) {
+		const configReadBefore = this.configOfFile.get(configFile);
+		if (configReadBefore !== void 0) return configReadBefore;
+		const config = typeScriptConfigAt(configFile);
+		this.configOfFile.set(configFile, config);
+		return config;
+	}
+	async aliasOptionsAt(configFile, configFilesExtending = /* @__PURE__ */ new Set()) {
+		const aliasOptionsReadBefore = this.aliasOptionsOfFile.get(configFile);
+		if (aliasOptionsReadBefore !== void 0) return aliasOptionsReadBefore;
+		const config = await this.configAt(configFile);
+		const extendsChain = new Set([...configFilesExtending, configFile]);
+		let inherited = NO_ALIAS_OPTIONS;
+		for (const extendedConfigFile of config.extendedConfigFiles) if (!extendsChain.has(extendedConfigFile)) inherited = ownOrInherited(await this.aliasOptionsAt(extendedConfigFile, extendsChain), inherited);
+		const aliasOptions = ownOrInherited(config.aliasOptions, inherited);
+		this.aliasOptionsOfFile.set(configFile, aliasOptions);
+		return aliasOptions;
+	}
+};
+const configFileIn = async (directory) => {
+	for (const configFileName of CONFIG_FILE_NAMES) {
+		const configFile = join(directory, configFileName);
+		if (await fileExists(configFile)) return configFile;
+	}
+};
+const aliasRulesDeclaredIn = async (directory) => {
+	const configFile = await configFileIn(directory);
+	if (configFile === void 0) return;
+	const configs = new TypeScriptConfigs();
+	const aliasOptions = await configs.aliasOptionsAt(configFile);
+	if (declaresAliases(aliasOptions)) return [aliasRulesOf(aliasOptions)];
+	const { referencedConfigFiles } = await configs.configAt(configFile);
+	return Promise.all(referencedConfigFiles.map(async (referencedConfigFile) => {
+		const { pathMapping } = aliasRulesOf(await configs.aliasOptionsAt(referencedConfigFile));
+		return {
+			pathMapping,
+			baseUrl: void 0
+		};
+	}));
+};
+var PathAliases = class {
+	aliasRules;
+	constructor(highestDirectory) {
+		this.aliasRules = new NearestDeclarations(highestDirectory, aliasRulesDeclaredIn);
+	}
+	async modulePathsFor(specifier, importingFile) {
+		return (await this.aliasRules.declarationAbove(importingFile) ?? []).map((rules) => modulePathsIn(rules, specifier)).find((modulePaths) => modulePaths.length > 0) ?? [];
+	}
+};
+//#endregion
+//#region src/scan/local-imports.ts
+const JAVASCRIPT_SOURCE_EXTENSIONS = [
+	".ts",
+	".tsx",
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".mts",
+	".cts",
+	".vue",
+	".svelte"
+];
+const TYPESCRIPT_EXTENSIONS_FOR = {
+	".js": [".ts", ".tsx"],
+	".jsx": [".tsx"],
+	".mjs": [".mts"],
+	".cjs": [".cts"]
+};
+const PYTHON_PACKAGE_FILE = "__init__.py";
+const DART_PACKAGE_SCHEME = "package:";
+const DART_LIBRARY_SCHEME = "dart:";
+const DART_IMPORT_DIRECTIVES = [
+	"import",
+	"export",
+	"part"
+];
+const DART_RE_EXPORT_DIRECTIVES = ["export"];
+const SWIFT_PACKAGE_MANIFEST = "Package.swift";
+const SWIFT_PACKAGE_TARGETS_DIRECTORIES = ["Sources", "Tests"];
+const XCODE_PROJECT_EXTENSION = ".xcodeproj";
+const stringAt = (code, index) => code.token(index)?.kind === "string" ? plainStringContent(code, {
+	first: index,
+	last: index
+}) : void 0;
+const unquoted = (text) => {
+	const trimmed = text.trim();
+	const quote = trimmed.charAt(0);
+	return (quote === "\"" || quote === "'") && trimmed.endsWith(quote) ? trimmed.slice(1, -1) : trimmed;
+};
+const directoriesUpFrom = (directory, highestDirectory) => {
+	const directories = [directory];
+	let current = directory;
+	while (current !== highestDirectory && dirname(current) !== current) {
+		current = dirname(current);
+		directories.push(current);
+	}
+	return directories;
+};
+const ancestorDirectory = (directory, levelsUp) => {
+	let ancestor = directory;
+	for (let level = 0; level < levelsUp; level += 1) ancestor = dirname(ancestor);
+	return ancestor;
+};
+const isRelativeSpecifier = (specifier) => specifier === "." || specifier === ".." || specifier.startsWith("./") || specifier.startsWith("../");
+const javascriptSpecifiers = (code) => code.tokens.flatMap((_token, index) => {
+	const specifier = code.isIdentifier(index - 1, "from") || code.isIdentifier(index - 1, "import") || code.isPunctuation(index - 1, "(") && (code.isIdentifier(index - 2, "import") || code.isIdentifier(index - 2, "require")) ? stringAt(code, index) : void 0;
+	return specifier === void 0 ? [] : [specifier];
+});
+const indexAfterReExportedNames = (code, exportIndex) => {
+	const namesIndex = exportIndex + 1;
+	if (code.isPunctuation(namesIndex, "{")) {
+		const closer = code.closerOf(namesIndex);
+		return closer === void 0 ? void 0 : closer + 1;
+	}
+	if (code.isPunctuation(namesIndex, "*")) return code.isIdentifier(namesIndex + 1, "as") ? namesIndex + 3 : namesIndex + 1;
+};
+const javascriptReExportSpecifiers = (code) => code.tokens.flatMap((_token, index) => {
+	const fromIndex = code.isIdentifier(index, "export") ? indexAfterReExportedNames(code, index) : void 0;
+	const specifier = fromIndex !== void 0 && code.isIdentifier(fromIndex, "from") ? stringAt(code, fromIndex + 1) : void 0;
+	return specifier === void 0 ? [] : [specifier];
+});
+const javascriptCandidates = (path) => {
+	const extension = extname(path);
+	const withoutExtension = path.slice(0, path.length - extension.length);
+	return [
+		...JAVASCRIPT_SOURCE_EXTENSIONS.includes(extension) ? [path] : [],
+		...(TYPESCRIPT_EXTENSIONS_FOR[extension] ?? []).map((typescriptExtension) => withoutExtension + typescriptExtension),
+		...JAVASCRIPT_SOURCE_EXTENSIONS.map((sourceExtension) => path + sourceExtension),
+		...JAVASCRIPT_SOURCE_EXTENSIONS.map((sourceExtension) => join(path, `index${sourceExtension}`))
+	];
+};
+const pythonImportedNames = (code, start) => {
+	const names = [];
+	let isInsideParentheses = false;
+	for (let index = start; index < code.tokens.length; index += 1) {
+		if (index > start && code.startsLine(index) && !isInsideParentheses) break;
+		if (code.isPunctuation(index, "(")) isInsideParentheses = true;
+		else if (code.isPunctuation(index, ")")) break;
+		else if (code.isIdentifier(index, "as")) index += 1;
+		else {
+			const token = code.token(index);
+			if (token?.kind === "identifier") names.push(token.text);
+		}
+	}
+	return names;
+};
+const pythonFromImport = (code, fromIndex) => {
+	let index = fromIndex + 1;
+	let level = 0;
+	while (code.isPunctuation(index, ".")) {
+		level += 1;
+		index += 1;
+	}
+	const modulePath = [];
+	for (let token = code.token(index); token?.kind === "identifier" && token.text !== "import"; token = code.token(index)) {
+		modulePath.push(token.text);
+		index += code.isPunctuation(index + 1, ".") ? 2 : 1;
+	}
+	return code.isIdentifier(index, "import") ? {
+		level,
+		modulePath,
+		names: pythonImportedNames(code, index + 1)
+	} : void 0;
+};
+const pythonPlainImports = (code, importIndex) => {
+	const imports = [];
+	let modulePath = [];
+	const endModule = () => {
+		if (modulePath.length > 0) imports.push({
+			level: 0,
+			modulePath,
+			names: []
+		});
+		modulePath = [];
+	};
+	for (let index = importIndex + 1; index < code.tokens.length && !code.startsLine(index); index += 1) if (code.isIdentifier(index, "as")) {
+		endModule();
+		index += 1;
+	} else if (code.isPunctuation(index, ",")) endModule();
+	else {
+		const token = code.token(index);
+		if (token?.kind === "identifier") modulePath.push(token.text);
+	}
+	endModule();
+	return imports;
+};
+const pythonImports = (code) => code.tokens.flatMap((_token, index) => {
+	if (!code.startsLine(index)) return [];
+	if (code.isIdentifier(index, "from")) {
+		const fromImport = pythonFromImport(code, index);
+		return fromImport === void 0 ? [] : [fromImport];
+	}
+	return code.isIdentifier(index, "import") ? pythonPlainImports(code, index) : [];
+});
+const isRelativePythonImport = (pythonImport) => pythonImport.level > 0;
+const pythonModuleFiles = (base, modulePath) => {
+	if (modulePath.length === 0) return [];
+	const path = join(base, ...modulePath);
+	return [`${path}.py`, join(path, PYTHON_PACKAGE_FILE)];
+};
+const dartPackageDeclaredIn = async (directory) => {
+	const nameLine = (await readFileIfPresent(join(directory, "pubspec.yaml")))?.split("\n").find((line) => line.startsWith("name:"));
+	return nameLine === void 0 ? void 0 : {
+		root: directory,
+		name: unquoted(nameLine.slice(5))
+	};
+};
+const goModuleDeclaredIn = async (directory) => {
+	const moduleLine = (await readFileIfPresent(join(directory, "go.mod")))?.split("\n").find((line) => line.startsWith("module "));
+	return moduleLine === void 0 ? void 0 : {
+		root: directory,
+		path: unquoted(moduleLine.slice(7))
+	};
+};
+const dartSpecifiers = (code, directives) => code.tokens.flatMap((_token, index) => {
+	const specifier = directives.some((directive) => code.isIdentifier(index - 1, directive)) ? stringAt(code, index) : void 0;
+	return specifier === void 0 || specifier.startsWith(DART_LIBRARY_SCHEME) ? [] : [specifier];
+});
+const goImportPaths = (code) => code.tokens.flatMap((_token, index) => {
+	if (!code.isIdentifier(index, "import")) return [];
+	const lastIndex = (code.isPunctuation(index + 1, "(") ? code.closerOf(index + 1) : void 0) ?? index + 1;
+	const paths = [];
+	for (let pathIndex = index + 1; pathIndex <= lastIndex; pathIndex += 1) {
+		const path = stringAt(code, pathIndex);
+		if (path !== void 0) paths.push(path);
+	}
+	return paths;
+});
+const swiftProjectDeclaredIn = async (directory) => {
+	const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+	if (entries.some((entry) => entry.isFile() && entry.name === SWIFT_PACKAGE_MANIFEST)) return {
+		kind: "swiftPackage",
+		root: directory
+	};
+	return entries.some((entry) => entry.isDirectory() && extname(entry.name) === XCODE_PROJECT_EXTENSION) ? {
+		kind: "xcodeProject",
+		root: directory
+	} : void 0;
+};
+const swiftPackageTargetOf = (packageRoot, directory) => {
+	const [targetsDirectory, targetName] = relative(packageRoot, directory).split(sep);
+	if (targetsDirectory === void 0 || !SWIFT_PACKAGE_TARGETS_DIRECTORIES.includes(targetsDirectory)) return packageRoot;
+	return targetName === void 0 ? join(packageRoot, targetsDirectory) : join(packageRoot, targetsDirectory, targetName);
+};
+const goPackageNameIn = (code) => {
+	const name = code.token(1);
+	return code.isIdentifier(0, "package") && name?.kind === "identifier" ? name.text : void 0;
+};
+const goPackageNameOfFile = async (file) => {
+	const contents = await readFileWithinSizeLimit(file);
+	return contents === void 0 ? void 0 : goPackageNameIn(new SourceCode(contents, "go"));
+};
+var LocalImports = class {
+	dartPackages;
+	goModules;
+	swiftProjects;
+	pathAliases;
+	goFilesOfDirectory = /* @__PURE__ */ new Map();
+	fileExistence = /* @__PURE__ */ new Map();
+	constructor(highestDirectory) {
+		this.highestDirectory = highestDirectory;
+		this.dartPackages = new NearestDeclarations(highestDirectory, dartPackageDeclaredIn);
+		this.goModules = new NearestDeclarations(highestDirectory, goModuleDeclaredIn);
+		this.swiftProjects = new NearestDeclarations(highestDirectory, swiftProjectDeclaredIn);
+		this.pathAliases = new PathAliases(highestDirectory);
+	}
+	filesImportedBy(code, file) {
+		switch (code.language) {
+			case "javascript": return this.javascriptFilesAt(javascriptSpecifiers(code), file);
+			case "python": return this.pythonFilesAt(pythonImports(code), file);
+			case "dart": return this.dartFilesAt(dartSpecifiers(code, DART_IMPORT_DIRECTIVES), file);
+			case "go": return this.goFilesImportedBy(code, file);
+			case "swift":
+			case "kotlin":
+			case "java":
+			case "csharp": return Promise.resolve([]);
+		}
+	}
+	filesOfSamePackageOrTarget(code, file) {
+		switch (code.language) {
+			case "go": return this.goFilesOfSamePackage(code, file);
+			case "swift": return this.swiftFilesOfSameTarget(file);
+			case "javascript":
+			case "python":
+			case "dart":
+			case "kotlin":
+			case "java":
+			case "csharp": return Promise.resolve([]);
+		}
+	}
+	filesReExportedBy(code, file) {
+		switch (code.language) {
+			case "javascript": return this.javascriptFilesAt(javascriptReExportSpecifiers(code), file);
+			case "python": return basename(file) === PYTHON_PACKAGE_FILE ? this.pythonFilesAt(pythonImports(code).filter(isRelativePythonImport), file) : Promise.resolve([]);
+			case "dart": return this.dartFilesAt(dartSpecifiers(code, DART_RE_EXPORT_DIRECTIVES), file);
+			case "go":
+			case "swift":
+			case "kotlin":
+			case "java":
+			case "csharp": return Promise.resolve([]);
+		}
+	}
+	fileExistsAt(path) {
+		const existenceCheckedBefore = this.fileExistence.get(path);
+		if (existenceCheckedBefore !== void 0) return existenceCheckedBefore;
+		const existence = fileExists(path);
+		this.fileExistence.set(path, existence);
+		return existence;
+	}
+	async firstExistingFile(candidates) {
+		for (const candidate of candidates) if (await this.fileExistsAt(candidate)) return candidate;
+	}
+	async existingFiles(candidates) {
+		const existing = [];
+		for (const candidate of candidates) if (await this.fileExistsAt(candidate)) existing.push(candidate);
+		return existing;
+	}
+	async javascriptFilesAt(specifiers, file) {
+		const files = [];
+		for (const specifier of specifiers) {
+			const modulePaths = isRelativeSpecifier(specifier) ? [join(dirname(file), specifier)] : await this.pathAliases.modulePathsFor(specifier, file);
+			const importedFile = await this.firstExistingFile(modulePaths.flatMap(javascriptCandidates));
+			if (importedFile !== void 0) files.push(importedFile);
+		}
+		return files;
+	}
+	async pythonFilesAt(imports, file) {
+		const files = [];
+		for (const { level, modulePath, names } of imports) {
+			const bases = level === 0 ? directoriesUpFrom(dirname(file), this.highestDirectory) : [ancestorDirectory(dirname(file), level - 1)];
+			for (const base of bases) {
+				const moduleFiles = await this.existingFiles([...pythonModuleFiles(base, modulePath), ...names.flatMap((name) => pythonModuleFiles(base, [...modulePath, name]))]);
+				if (moduleFiles.length > 0) {
+					files.push(...moduleFiles);
+					break;
+				}
+			}
+		}
+		return files;
+	}
+	async dartFilesAt(specifiers, file) {
+		const ownPackage = await this.dartPackages.declarationAbove(file);
+		const candidates = specifiers.flatMap((specifier) => {
+			if (!specifier.startsWith(DART_PACKAGE_SCHEME)) return [join(dirname(file), specifier)];
+			const [packageName, ...pathInPackage] = specifier.slice(8).split("/");
+			return ownPackage !== void 0 && packageName === ownPackage.name ? [join(ownPackage.root, "lib", ...pathInPackage)] : [];
+		});
+		return this.existingFiles(candidates);
+	}
+	async goFilesImportedBy(code, file) {
+		const module = await this.goModules.declarationAbove(file);
+		if (module === void 0) return [];
+		const packageDirectories = goImportPaths(code).filter((path) => path === module.path || path.startsWith(`${module.path}/`)).map((path) => join(module.root, path.slice(module.path.length)));
+		return (await Promise.all(packageDirectories.map((directory) => this.goFilesIn(directory)))).flat();
+	}
+	async goFilesOfSamePackage(code, file) {
+		const packageName = goPackageNameIn(code);
+		if (packageName === void 0) return [];
+		const files = await this.goFilesIn(dirname(file));
+		const packageNames = await Promise.all(files.map(goPackageNameOfFile));
+		return files.filter((_file, index) => packageNames[index] === packageName);
+	}
+	async swiftFilesOfSameTarget(file) {
+		const target = await this.swiftTargetOfDirectory(dirname(file));
+		return this.swiftFilesOfTargetIn(target, target);
+	}
+	async swiftFilesOfTargetIn(target, directory) {
+		const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+		const files = entries.filter((entry) => entry.isFile() && extname(entry.name) === ".swift").map((entry) => join(directory, entry.name));
+		const filesOfSubdirectories = await Promise.all(entries.filter((entry) => entry.isDirectory()).map(async (entry) => {
+			const subdirectory = join(directory, entry.name);
+			return await this.swiftTargetOfDirectory(subdirectory) === target ? this.swiftFilesOfTargetIn(target, subdirectory) : [];
+		}));
+		return [...files, ...filesOfSubdirectories.flat()];
+	}
+	async swiftTargetOfDirectory(directory) {
+		const project = await this.swiftProjects.declarationAtOrAbove(directory);
+		if (project === void 0) return directory;
+		switch (project.kind) {
+			case "swiftPackage": return swiftPackageTargetOf(project.root, directory);
+			case "xcodeProject": return project.root;
+		}
+	}
+	goFilesIn(directory) {
+		const filesListedBefore = this.goFilesOfDirectory.get(directory);
+		if (filesListedBefore !== void 0) return filesListedBefore;
+		const files = readdir(directory, { withFileTypes: true }).then((entries) => entries.filter((entry) => entry.isFile() && extname(entry.name) === ".go").map((entry) => join(directory, entry.name)), () => []);
+		this.goFilesOfDirectory.set(directory, files);
+		return files;
+	}
+};
+//#endregion
+//#region src/scan/project-areas.ts
+const GRADLE_BUILD_FILES = ["build.gradle.kts", "build.gradle"];
+const MAVEN_BUILD_FILE = "pom.xml";
+const ANDROID_MODULE_MARKERS = [
+	"com.android.",
+	"android {",
+	"android{"
+];
+const NUXT_CONFIG_FILES = [
+	"nuxt.config.ts",
+	"nuxt.config.js",
+	"nuxt.config.mjs",
+	"nuxt.config.mts"
+];
+const NUXT_SERVER_DIRECTORY = "server";
+const buildModuleDeclaredIn = async (directory) => {
+	for (const buildFile of GRADLE_BUILD_FILES) {
+		const contents = await readFileIfPresent(join(directory, buildFile));
+		if (contents !== void 0) return ANDROID_MODULE_MARKERS.some((marker) => contents.includes(marker)) ? "android" : "jvm";
+	}
+	return await readFileIfPresent(join(directory, MAVEN_BUILD_FILE)) === void 0 ? void 0 : "jvm";
+};
+const nuxtAppRootDeclaredIn = async (directory) => {
+	for (const configFile of NUXT_CONFIG_FILES) if (await fileExists(join(directory, configFile))) return directory;
+};
+var ProjectAreas = class {
+	buildModules;
+	nuxtAppRoots;
+	constructor(highestDirectory) {
+		this.buildModules = new NearestDeclarations(highestDirectory, buildModuleDeclaredIn);
+		this.nuxtAppRoots = new NearestDeclarations(highestDirectory, nuxtAppRootDeclaredIn);
+	}
+	async contain(area, file) {
+		switch (area) {
+			case "android-module": return await this.buildModuleOf(file) === "android";
+			case "jvm-module": return await this.buildModuleOf(file) === "jvm";
+			case "nuxt-app": return !await this.isInNuxtServerDirectory(file);
+			case "nuxt-server": return this.isInNuxtServerDirectory(file);
+		}
+	}
+	async buildModuleOf(file) {
+		return await this.buildModules.declarationAbove(file) ?? "jvm";
+	}
+	async isInNuxtServerDirectory(file) {
+		const appRoot = await this.nuxtAppRoots.declarationAbove(file);
+		return appRoot !== void 0 && relative(appRoot, file).split(sep)[0] === NUXT_SERVER_DIRECTORY;
+	}
+};
+//#endregion
+//#region src/scan/sdk-families.ts
+const sdkTypes = ["client", "server"];
+const javascriptExtensions = [
+	".js",
+	".jsx",
+	".mjs",
+	".cjs",
+	".ts",
+	".tsx",
+	".mts",
+	".cts"
+];
+const browserExtensions = [
+	...javascriptExtensions,
+	".vue",
+	".svelte"
+];
+const vueExtensions = [...javascriptExtensions, ".vue"];
+const read = (name, options = {}) => ({
+	name,
+	form: "method",
+	argumentCount: options.argumentCount,
+	keyArgument: {
+		kind: "key",
+		slot: options.key ?? { position: 0 }
+	},
+	inCodeDefault: options.inCodeDefault ?? { position: 1 },
+	getterType: options.getterType,
+	test: false
+});
+const readFunction = (name, options = {}) => ({
+	...read(name, options),
+	form: "function"
+});
+const typedReads = (namesByGetterType, options = {}) => Object.entries(namesByGetterType).flatMap(([getterType, names]) => names.map((name) => read(name, {
+	...options,
+	getterType
+})));
+const keyOnly = (name, key = { position: 0 }) => ({
+	name,
+	form: "method",
+	keyArgument: {
+		kind: "key",
+		slot: key
+	},
+	test: false
+});
+const testMethod = (name, key = { position: 0 }) => ({
+	...keyOnly(name, key),
+	test: true
+});
+const testMap = (name, form, slot = { position: 0 }, property) => ({
+	name,
+	form,
+	keyArgument: {
+		kind: "mapKeys",
+		slot,
+		property
+	},
+	test: true
+});
+const testAnnotation = (name) => ({
+	name,
+	form: "annotation",
+	keyArgument: {
+		kind: "key",
+		slot: { label: "key" }
+	},
+	test: true
+});
+const javascriptClientCalls = [
+	read("getValue"),
+	read("watch"),
+	keyOnly("unwatch")
+];
+const javascriptTestClientCalls = [
+	testMap("createTestClient", "function", { position: 0 }, "values"),
+	testMethod("setValue"),
+	testMethod("removeValue"),
+	testMap("replaceValues", "method")
+];
+const openFeatureJavascriptGetters = typedReads({
+	boolean: ["getBooleanValue", "getBooleanDetails"],
+	string: ["getStringValue", "getStringDetails"],
+	number: ["getNumberValue", "getNumberDetails"],
+	json: ["getObjectValue", "getObjectDetails"]
+});
+const pythonLabels = {
+	key: {
+		position: 0,
+		label: "config_key"
+	},
+	inCodeDefault: {
+		position: 1,
+		label: "default"
+	}
+};
+const openFeaturePythonLabels = {
+	key: {
+		position: 0,
+		label: "flag_key"
+	},
+	inCodeDefault: {
+		position: 1,
+		label: "default_value"
+	}
+};
+const csharpLabels = {
+	key: {
+		position: 0,
+		label: "configKey"
+	},
+	inCodeDefault: {
+		position: 1,
+		label: "defaultValue"
+	}
+};
+const openFeatureCsharpLabels = {
+	key: {
+		position: 0,
+		label: "flagKey"
+	},
+	inCodeDefault: {
+		position: 1,
+		label: "defaultValue"
+	}
+};
+const openFeatureGoArguments = {
+	key: { position: 1 },
+	inCodeDefault: { position: 2 },
+	argumentCount: { minimum: 4 }
+};
+const kotlinLabels = {
+	key: {
+		position: 0,
+		label: "key"
+	},
+	inCodeDefault: {
+		position: 1,
+		label: "defaultValue"
+	}
+};
+const swiftLabels = {
+	key: { label: "for" },
+	inCodeDefault: { label: "default" }
+};
+const openFeatureSwiftLabels = {
+	key: { label: "key" },
+	inCodeDefault: { label: "defaultValue" }
+};
+const sdkFamilies = {
+	"js-client": {
+		sdkType: "client",
+		extensions: browserExtensions,
+		importMarkers: ["@configdirector/client-sdk"],
+		calls: [...javascriptClientCalls, ...javascriptTestClientCalls]
+	},
+	"js-server": {
+		sdkType: "server",
+		extensions: javascriptExtensions,
+		importMarkers: ["@configdirector/server-sdk"],
+		calls: [...javascriptClientCalls, ...javascriptTestClientCalls]
+	},
+	react: {
+		sdkType: "client",
+		extensions: javascriptExtensions,
+		importMarkers: ["@configdirector/react-web-sdk"],
+		calls: [
+			readFunction("useConfigValue"),
+			...javascriptClientCalls,
+			...javascriptTestClientCalls
+		]
+	},
+	"react-native": {
+		sdkType: "client",
+		extensions: javascriptExtensions,
+		importMarkers: ["@configdirector/react-native-sdk"],
+		calls: [
+			readFunction("useConfigValue"),
+			...javascriptClientCalls,
+			...javascriptTestClientCalls
+		]
+	},
+	vue: {
+		sdkType: "client",
+		extensions: vueExtensions,
+		importMarkers: ["@configdirector/vue-sdk"],
+		calls: [
+			readFunction("useConfigValue"),
+			...javascriptClientCalls,
+			...javascriptTestClientCalls
+		]
+	},
+	"nuxt-client": {
+		sdkType: "client",
+		extensions: vueExtensions,
+		importMarkers: [
+			"useConfigDirectorValue",
+			"useConfigDirectorClient",
+			"@configdirector/nuxt-sdk"
+		],
+		projectArea: "nuxt-app",
+		calls: [
+			readFunction("useConfigDirectorValue"),
+			...javascriptClientCalls,
+			...javascriptTestClientCalls
+		]
+	},
+	"nuxt-server": {
+		sdkType: "server",
+		extensions: javascriptExtensions,
+		importMarkers: ["useConfigDirectorClient"],
+		projectArea: "nuxt-server",
+		calls: javascriptClientCalls
+	},
+	"nextjs-client": {
+		sdkType: "client",
+		extensions: javascriptExtensions,
+		importMarkers: ["@configdirector/nextjs-sdk/client"],
+		calls: [
+			readFunction("useConfigValue"),
+			...javascriptClientCalls,
+			...javascriptTestClientCalls
+		]
+	},
+	"nextjs-server": {
+		sdkType: "server",
+		extensions: javascriptExtensions,
+		importMarkers: ["@configdirector/nextjs-sdk/server"],
+		calls: [...javascriptClientCalls, ...javascriptTestClientCalls]
+	},
+	"openfeature-web": {
+		sdkType: "client",
+		extensions: browserExtensions,
+		importMarkers: ["@openfeature/web-sdk"],
+		calls: openFeatureJavascriptGetters
+	},
+	"openfeature-node": {
+		sdkType: "server",
+		extensions: javascriptExtensions,
+		importMarkers: ["@openfeature/server-sdk"],
+		calls: openFeatureJavascriptGetters
+	},
+	flutter: {
+		sdkType: "client",
+		extensions: [".dart"],
+		importMarkers: ["package:configdirector_flutter_client_sdk/"],
+		calls: [
+			read("getValue"),
+			read("evaluate"),
+			read("watch"),
+			keyOnly("unwatch"),
+			testMap("createTestClient", "function", { label: "values" }),
+			testMethod("setValue"),
+			testMethod("removeValue"),
+			testMap("replaceValues", "method")
+		]
+	},
+	"openfeature-flutter": {
+		sdkType: "client",
+		extensions: [".dart"],
+		importMarkers: ["package:openfeature_dart_client_sdk/"],
+		calls: typedReads({
+			boolean: ["getBooleanValue", "getBooleanDetails"],
+			string: ["getStringValue", "getStringDetails"],
+			integer: ["getIntegerValue", "getIntegerDetails"],
+			float: ["getDoubleValue", "getDoubleDetails"],
+			json: ["getStructureValue", "getStructureDetails"]
+		})
+	},
+	swift: {
+		sdkType: "client",
+		extensions: [".swift"],
+		importMarkers: ["import ConfigDirector"],
+		providerPackagesContainingMarkers: ["ConfigDirectorOpenFeatureProvider"],
+		calls: [
+			read("value", swiftLabels),
+			read("values", swiftLabels),
+			testMap("makeTestClient", "function", { label: "values" }),
+			testMethod("setValue", { label: "for" }),
+			testMethod("removeValue", { label: "for" }),
+			testMap("replaceValues", "method")
+		]
+	},
+	"openfeature-swift": {
+		sdkType: "client",
+		extensions: [".swift"],
+		importMarkers: ["import OpenFeature"],
+		calls: [
+			...typedReads({
+				boolean: ["getBooleanValue", "getBooleanDetails"],
+				string: ["getStringValue", "getStringDetails"],
+				integer: ["getIntegerValue", "getIntegerDetails"],
+				float: ["getDoubleValue", "getDoubleDetails"],
+				json: ["getObjectValue", "getObjectDetails"]
+			}, openFeatureSwiftLabels),
+			read("getValue", openFeatureSwiftLabels),
+			read("getDetails", openFeatureSwiftLabels)
+		]
+	},
+	android: {
+		sdkType: "client",
+		extensions: [".kt", ".java"],
+		importMarkers: ["com.configdirector"],
+		providerPackagesContainingMarkers: ["com.configdirector.openfeature"],
+		projectArea: "android-module",
+		calls: [
+			read("value", kotlinLabels),
+			read("values", kotlinLabels),
+			read("evaluate", kotlinLabels),
+			...typedReads({
+				boolean: [
+					"getBoolean",
+					"evaluateBoolean",
+					"watchBoolean"
+				],
+				string: [
+					"getString",
+					"evaluateString",
+					"watchString"
+				],
+				integer: [
+					"getInt",
+					"evaluateInt",
+					"watchInt"
+				],
+				float: [
+					"getDouble",
+					"evaluateDouble",
+					"watchDouble"
+				],
+				json: [
+					"getJsonObject",
+					"getJsonArray",
+					"evaluateJsonObject",
+					"evaluateJsonArray",
+					"watchJsonObject",
+					"watchJsonArray"
+				]
+			}, kotlinLabels),
+			readFunction("configValue", kotlinLabels),
+			testMap("createTestClient", "function", {
+				position: 0,
+				label: "values"
+			}),
+			testMethod("setValue", {
+				position: 0,
+				label: "key"
+			}),
+			testMethod("removeValue", {
+				position: 0,
+				label: "key"
+			}),
+			testMap("replaceValues", "method")
+		]
+	},
+	"openfeature-android": {
+		sdkType: "client",
+		extensions: [".kt", ".java"],
+		importMarkers: ["dev.openfeature.kotlin.sdk"],
+		calls: typedReads({
+			boolean: ["getBooleanValue", "getBooleanDetails"],
+			string: ["getStringValue", "getStringDetails"],
+			integer: ["getIntegerValue", "getIntegerDetails"],
+			float: ["getDoubleValue", "getDoubleDetails"],
+			json: ["getObjectValue", "getObjectDetails"]
+		}, kotlinLabels)
+	},
+	java: {
+		sdkType: "server",
+		extensions: [".java", ".kt"],
+		importMarkers: ["com.configdirector"],
+		providerPackagesContainingMarkers: ["com.configdirector.openfeature"],
+		projectArea: "jvm-module",
+		calls: [
+			...typedReads({
+				boolean: ["getBoolean", "watchBoolean"],
+				string: ["getString", "watchString"],
+				integer: ["getInteger", "watchInteger"],
+				float: ["getDouble", "watchDouble"],
+				json: [
+					"getJsonObject",
+					"getJsonArray",
+					"watchJsonObject",
+					"watchJsonArray"
+				]
+			}),
+			read("getValue"),
+			read("watch"),
+			keyOnly("unwatch"),
+			testMap("createTestClient", "function"),
+			testMethod("setValue"),
+			testMethod("setJsonValue"),
+			testMethod("removeValue"),
+			testMap("replaceValues", "method"),
+			testAnnotation("BooleanConfigValue"),
+			testAnnotation("StringConfigValue"),
+			testAnnotation("IntegerConfigValue"),
+			testAnnotation("FloatConfigValue"),
+			testAnnotation("JsonConfigValue")
+		]
+	},
+	"openfeature-java": {
+		sdkType: "server",
+		extensions: [".java", ".kt"],
+		importMarkers: ["dev.openfeature.sdk"],
+		calls: typedReads({
+			boolean: ["getBooleanValue", "getBooleanDetails"],
+			string: ["getStringValue", "getStringDetails"],
+			integer: [
+				"getIntegerValue",
+				"getIntegerDetails",
+				"getLongValue",
+				"getLongDetails"
+			],
+			float: ["getDoubleValue", "getDoubleDetails"],
+			json: ["getObjectValue", "getObjectDetails"]
+		})
+	},
+	python: {
+		sdkType: "server",
+		extensions: [".py"],
+		importMarkers: ["import configdirector", "from configdirector"],
+		providerPackagesContainingMarkers: ["configdirector_openfeature"],
+		calls: [
+			read("get_value", pythonLabels),
+			read("watch", pythonLabels),
+			keyOnly("unwatch", pythonLabels.key),
+			testMap("create_test_client", "function", {
+				position: 0,
+				label: "values"
+			}),
+			testMethod("set_value", {
+				position: 0,
+				label: "key"
+			}),
+			testMethod("remove_value", {
+				position: 0,
+				label: "key"
+			}),
+			testMap("replace_values", "method", {
+				position: 0,
+				label: "values"
+			})
+		]
+	},
+	"openfeature-python": {
+		sdkType: "server",
+		extensions: [".py"],
+		importMarkers: ["import openfeature", "from openfeature"],
+		calls: typedReads({
+			boolean: [
+				"get_boolean_value",
+				"get_boolean_details",
+				"get_boolean_value_async",
+				"get_boolean_details_async"
+			],
+			string: [
+				"get_string_value",
+				"get_string_details",
+				"get_string_value_async",
+				"get_string_details_async"
+			],
+			integer: [
+				"get_integer_value",
+				"get_integer_details",
+				"get_integer_value_async",
+				"get_integer_details_async"
+			],
+			float: [
+				"get_float_value",
+				"get_float_details",
+				"get_float_value_async",
+				"get_float_details_async"
+			],
+			json: [
+				"get_object_value",
+				"get_object_details",
+				"get_object_value_async",
+				"get_object_details_async"
+			]
+		}, openFeaturePythonLabels)
+	},
+	dotnet: {
+		sdkType: "server",
+		extensions: [".cs"],
+		importMarkers: [
+			"using ConfigDirector",
+			"ConfigDirectorClient",
+			"ConfigDirectorTesting"
+		],
+		providerPackagesContainingMarkers: ["ConfigDirector.OpenFeature"],
+		calls: [
+			read("GetValue", csharpLabels),
+			read("Watch", csharpLabels),
+			...typedReads({ json: ["GetJsonValue", "WatchJson"] }, csharpLabels),
+			keyOnly("Unwatch", csharpLabels.key),
+			testMap("CreateTestClient", "function", {
+				position: 0,
+				label: "values"
+			}),
+			testMethod("SetValue", {
+				position: 0,
+				label: "key"
+			}),
+			testMethod("RemoveValue", {
+				position: 0,
+				label: "key"
+			}),
+			testMap("ReplaceValues", "method", {
+				position: 0,
+				label: "values"
+			})
+		]
+	},
+	"openfeature-dotnet": {
+		sdkType: "server",
+		extensions: [".cs"],
+		importMarkers: ["using OpenFeature", "FeatureClient"],
+		calls: typedReads({
+			boolean: ["GetBooleanValueAsync", "GetBooleanDetailsAsync"],
+			string: ["GetStringValueAsync", "GetStringDetailsAsync"],
+			integer: ["GetIntegerValueAsync", "GetIntegerDetailsAsync"],
+			float: ["GetDoubleValueAsync", "GetDoubleDetailsAsync"],
+			json: ["GetObjectValueAsync", "GetObjectDetailsAsync"]
+		}, openFeatureCsharpLabels)
+	},
+	go: {
+		sdkType: "server",
+		extensions: [".go"],
+		importMarkers: ["github.com/ConfigDirector/go-sdks/configdirector"],
+		providerPackagesContainingMarkers: ["github.com/ConfigDirector/go-sdks/configdirector-openfeature"],
+		calls: [
+			...typedReads({
+				boolean: ["BoolValue", "BoolValueDetails"],
+				string: ["StringValue", "StringValueDetails"],
+				integer: ["IntValue", "IntValueDetails"],
+				float: ["FloatValue", "FloatValueDetails"],
+				json: ["JSONValue", "JSONValueDetails"]
+			}, { argumentCount: {
+				minimum: 3,
+				maximum: 3
+			} }),
+			...typedReads({
+				boolean: ["WatchBool"],
+				string: ["WatchString"],
+				integer: ["WatchInt"],
+				float: ["WatchFloat"],
+				json: ["WatchJSON"]
+			}, { argumentCount: {
+				minimum: 4,
+				maximum: 4
+			} }),
+			testMap("NewTestClient", "function"),
+			testMethod("SetValue"),
+			testMethod("RemoveValue"),
+			testMap("ReplaceValues", "method")
+		]
+	},
+	"openfeature-go": {
+		sdkType: "server",
+		extensions: [".go"],
+		importMarkers: ["github.com/open-feature/go-sdk/openfeature"],
+		calls: typedReads({
+			boolean: [
+				"Boolean",
+				"BooleanValue",
+				"BooleanValueDetails"
+			],
+			string: [
+				"String",
+				"StringValue",
+				"StringValueDetails"
+			],
+			integer: [
+				"Int",
+				"IntValue",
+				"IntValueDetails"
+			],
+			float: [
+				"Float",
+				"FloatValue",
+				"FloatValueDetails"
+			],
+			json: [
+				"Object",
+				"ObjectValue",
+				"ObjectValueDetails"
+			]
+		}, openFeatureGoArguments)
+	}
+};
+const allSdkFamilies = Object.keys(sdkFamilies);
+//#endregion
+//#region src/scan/map-literals.ts
+const KOTLIN_MAP_BUILDERS = new Set([
+	"mapOf",
+	"mutableMapOf",
+	"hashMapOf",
+	"linkedMapOf"
+]);
+const itemsOfGroup = (code, opener) => opener === void 0 ? void 0 : code.commaSeparatedItems(opener);
+const splitAt = (item, separator) => {
+	if (separator === void 0 || separator === item.first || separator === item.last) return {
+		key: item,
+		keyIsName: false,
+		value: void 0
+	};
+	return {
+		key: {
+			first: item.first,
+			last: separator - 1
+		},
+		keyIsName: false,
+		value: {
+			first: separator + 1,
+			last: item.last
+		}
+	};
+};
+const entriesSeparatedByColon = (code, items) => items.map((item) => splitAt(item, code.firstTopLevelIndex(item, (index) => code.isPunctuation(index, ":"))));
+const entriesInClosingBraces = (code, range) => {
+	const items = itemsOfGroup(code, code.openerOfLastToken(range, "}"));
+	return items === void 0 ? void 0 : entriesSeparatedByColon(code, items);
+};
+const javascriptEntry = (code, item) => {
+	const first = code.token(item.first);
+	if (item.first === item.last && first?.kind === "identifier") return {
+		key: item,
+		keyIsName: true,
+		value: item
+	};
+	const entry = splitAt(item, code.firstTopLevelIndex(item, (index) => code.isPunctuation(index, ":")));
+	return {
+		...entry,
+		keyIsName: entry.key.first === entry.key.last && first?.kind === "identifier"
+	};
+};
+const kotlinMapBuilderOpener = (code, range) => {
+	const opener = code.openerOfLastToken(range, ")");
+	const builder = code.token(range.first);
+	return opener !== void 0 && builder?.kind === "identifier" && KOTLIN_MAP_BUILDERS.has(builder.text) ? opener : void 0;
+};
+const javaMapOfOpener = (code, range) => code.isIdentifier(range.first, "Map") && code.isPunctuation(range.first + 1, ".") && code.isIdentifier(range.first + 2, "of") && code.openerOfLastToken(range, ")") === range.first + 3 ? range.first + 3 : void 0;
+const alternatingEntries = (items) => items.flatMap((item, position) => position % 2 === 0 ? [{
+	key: item,
+	keyIsName: false,
+	value: items[position + 1]
+}] : []);
+const csharpEntry = (code, item) => {
+	const indexerCloser = code.isPunctuation(item.first, "[") ? code.closerOf(item.first) : void 0;
+	if (indexerCloser !== void 0 && code.isPunctuation(indexerCloser + 1, "=")) return {
+		key: {
+			first: item.first + 1,
+			last: indexerCloser - 1
+		},
+		keyIsName: false,
+		value: {
+			first: indexerCloser + 2,
+			last: item.last
+		}
+	};
+	const [key, value] = (code.isPunctuation(item.first, "{") ? itemsOfGroup(code, item.first) : void 0) ?? [];
+	return key === void 0 ? {
+		key: item,
+		keyIsName: false,
+		value: void 0
+	} : {
+		key,
+		keyIsName: false,
+		value
+	};
+};
+const mapLiteralEntries = {
+	javascript: (code, range) => code.openerOfLastToken(range, "}") === range.first ? itemsOfGroup(code, range.first)?.map((item) => javascriptEntry(code, item)) : void 0,
+	python: (code, range) => code.openerOfLastToken(range, "}") === range.first ? entriesSeparatedByColon(code, itemsOfGroup(code, range.first) ?? []) : void 0,
+	dart: entriesInClosingBraces,
+	swift: (code, range) => code.openerOfLastToken(range, "]") === range.first ? entriesSeparatedByColon(code, (itemsOfGroup(code, range.first) ?? []).filter((item) => !code.isPunctuation(item.first, ":"))) : void 0,
+	go: entriesInClosingBraces,
+	kotlin: (code, range) => itemsOfGroup(code, kotlinMapBuilderOpener(code, range))?.map((item) => splitAt(item, code.firstTopLevelIndex(item, (index) => code.isIdentifier(index, "to")))),
+	java: (code, range) => {
+		const items = itemsOfGroup(code, javaMapOfOpener(code, range));
+		return items === void 0 ? void 0 : alternatingEntries(items);
+	},
+	csharp: (code, range) => itemsOfGroup(code, code.openerOfLastToken(range, "}"))?.map((item) => csharpEntry(code, item))
+};
+//#endregion
+//#region src/scan/sdk-calls.ts
+const LABEL_SEPARATORS = new Set([":", "="]);
+const CHARACTERS_EXTENDING_A_SEPARATOR = new Set([
+	":",
+	"=",
+	">"
+]);
+const labelledArgument = (code, item) => {
+	const labelToken = code.token(item.first);
+	const separator = code.token(item.first + 1);
+	return labelToken?.kind === "identifier" && separator?.kind === "punctuation" && LABEL_SEPARATORS.has(separator.text) && !CHARACTERS_EXTENDING_A_SEPARATOR.has(code.characterAfter(item.first + 1)) && item.first + 2 <= item.last ? {
+		label: labelToken.text,
+		range: {
+			first: item.first + 2,
+			last: item.last
+		}
+	} : {
+		label: void 0,
+		range: item
+	};
+};
+const argumentInSlot = (callArguments, slot) => {
+	const labelled = callArguments.find((argument) => slot.label !== void 0 && argument.label === slot.label);
+	if (labelled !== void 0) return labelled;
+	const positional = slot.position === void 0 ? void 0 : callArguments[slot.position];
+	return positional?.label === void 0 ? positional : void 0;
+};
+const precedingTokenMatchesForm = (code, nameIndex, shape) => {
+	switch (shape.form) {
+		case "method": return code.isPunctuation(nameIndex - 1, ".");
+		case "annotation": return code.isPunctuation(nameIndex - 1, "@");
+		case "function": return true;
+	}
+};
+const dynamicReferenceOf = ({ line, sdk, call, argument }) => ({
+	line,
+	sdk,
+	call,
+	argument
+});
+const RAW_VALUE_ACCESSOR = "rawValue";
+const rangeInsideBrackets = (code, range) => code.isPunctuation(range.first, "[") && code.closerOf(range.first) === range.last ? {
+	first: range.first + 1,
+	last: range.last - 1
+} : range;
+const dottedPathSegments = (code, range) => {
+	const path = rangeInsideBrackets(code, range);
+	const tokenCount = path.last - path.first + 1;
+	if (tokenCount < 1 || tokenCount % 2 === 0) return;
+	const segments = [];
+	for (let index = path.first; index <= path.last; index += 2) {
+		const segment = code.token(index);
+		if (segment?.kind !== "identifier" || index < path.last && !code.isPunctuation(index + 1, ".")) return;
+		segments.push(segment.text);
+	}
+	return segments;
+};
+const nameReadForKey = (code, range) => {
+	const segments = dottedPathSegments(code, range);
+	if (segments === void 0) return;
+	const accessesRawValue = segments.length > 1 && segments[segments.length - 1] === RAW_VALUE_ACCESSOR;
+	return segments[segments.length - (accessesRawValue ? 2 : 1)];
+};
+const TOKENS_SEARCHED_FOR_THE_END_OF_TYPE_ARGUMENTS = 64;
+const TOKENS_ENDING_A_SEARCH_FOR_TYPE_ARGUMENTS = new Set([
+	"(",
+	")",
+	"{",
+	"}",
+	";"
+]);
+const indexAfterTypeArguments = (code, openingAngleBracket) => {
+	let depth = 0;
+	const lastSearched = openingAngleBracket + TOKENS_SEARCHED_FOR_THE_END_OF_TYPE_ARGUMENTS;
+	for (let index = openingAngleBracket; index <= lastSearched; index += 1) {
+		const token = code.token(index);
+		if (token === void 0 || token.kind === "punctuation" && TOKENS_ENDING_A_SEARCH_FOR_TYPE_ARGUMENTS.has(token.text)) return;
+		if (code.isPunctuation(index, "<")) depth += 1;
+		else if (code.isPunctuation(index, ">")) {
+			depth -= 1;
+			if (depth === 0) return index + 1;
+		}
+	}
+};
+const openingParenthesisAfterName = (code, nameIndex) => {
+	const afterName = code.opensTypeArguments(nameIndex + 1) ? indexAfterTypeArguments(code, nameIndex + 1) : nameIndex + 1;
+	return afterName !== void 0 && code.isPunctuation(afterName, "(") ? afterName : void 0;
+};
+const mapKeyExpressions = (code, range, property) => {
+	const entries = mapLiteralEntries[code.language](code, range);
+	if (entries === void 0) return [{
+		range,
+		isName: false
+	}];
+	if (property === void 0) return entries.map((entry) => ({
+		range: entry.key,
+		isName: entry.keyIsName
+	}));
+	const propertyEntry = entries.find((entry) => literalTextOf(code, {
+		range: entry.key,
+		isName: entry.keyIsName
+	}) === property);
+	return propertyEntry?.value === void 0 ? [] : mapKeyExpressions(code, propertyEntry.value, void 0);
+};
+const keyExpressionsOf = (code, callArguments, keyArgument) => {
+	const argument = argumentInSlot(callArguments, keyArgument.slot);
+	if (argument === void 0) return [];
+	switch (keyArgument.kind) {
+		case "key": return [{
+			range: argument.range,
+			isName: false
+		}];
+		case "mapKeys": return mapKeyExpressions(code, argument.range, keyArgument.property);
+	}
+};
+const callArgumentsOf = (code, nameIndex) => {
+	const openingParenthesis = openingParenthesisAfterName(code, nameIndex);
+	return (openingParenthesis === void 0 ? void 0 : code.commaSeparatedItems(openingParenthesis))?.map((item) => labelledArgument(code, item));
+};
+const hasArgumentCountOf = (shape, callArguments) => shape.argumentCount === void 0 || callArguments.length >= shape.argumentCount.minimum && callArguments.length <= (shape.argumentCount.maximum ?? Number.POSITIVE_INFINITY);
+const collectCallReferences = (code, nameIndex, sdk, shape, matches) => {
+	const callArguments = precedingTokenMatchesForm(code, nameIndex, shape) ? callArgumentsOf(code, nameIndex) : void 0;
+	if (callArguments === void 0 || !hasArgumentCountOf(shape, callArguments)) return;
+	const inCodeDefaultArgument = shape.inCodeDefault === void 0 ? void 0 : argumentInSlot(callArguments, shape.inCodeDefault);
+	const inCodeDefault = inCodeDefaultArgument === void 0 ? void 0 : inCodeDefaultValueOf(code, inCodeDefaultArgument.range);
+	for (const expression of keyExpressionsOf(code, callArguments, shape.keyArgument)) {
+		const line = code.lineOf(expression.range.first);
+		const keyLiteral = keyLiteralOf(code, expression);
+		const tokenIndex = expression.range.first;
+		const call = {
+			line,
+			sdk,
+			call: shape.name,
+			inCodeDefault,
+			getterType: shape.getterType,
+			test: shape.test
+		};
+		switch (keyLiteral.kind) {
+			case "key":
+				matches.push({
+					tokenIndex,
+					kind: "direct",
+					reference: {
+						...call,
+						key: keyLiteral.key,
+						argument: void 0
+					}
+				});
+				break;
+			case "notLiteral": {
+				const reference = {
+					...call,
+					argument: code.textOf(expression.range)
+				};
+				const name = nameReadForKey(code, expression.range);
+				if (name === void 0) matches.push({
+					tokenIndex,
+					kind: "dynamic",
+					reference: dynamicReferenceOf(reference)
+				});
+				else matches.push({
+					tokenIndex,
+					kind: "named",
+					name,
+					reference
+				});
+				break;
+			}
+			case "outsideKeyGrammar": break;
+		}
+	}
+};
+const sdkCallMatches = (code, callShapes) => {
+	const shapesByName = /* @__PURE__ */ new Map();
+	for (const callShape of callShapes) {
+		const shapesNamedAlike = shapesByName.get(callShape.shape.name);
+		if (shapesNamedAlike === void 0) shapesByName.set(callShape.shape.name, [callShape]);
+		else shapesNamedAlike.push(callShape);
+	}
+	const matches = [];
+	code.tokens.forEach((token, index) => {
+		if (token.kind !== "identifier") return;
+		for (const { sdk, shape } of shapesByName.get(token.text) ?? []) collectCallReferences(code, index, sdk, shape, matches);
+	});
+	return matches;
+};
+//#endregion
+//#region src/scan/test-files.ts
+const TEST_DIRECTORY_NAMES = new Set([
+	"test",
+	"tests",
+	"__tests__",
+	"spec",
+	"specs",
+	"androidtest"
+]);
+const TEST_FILE_NAME_SUFFIXES = [
+	".test",
+	".spec",
+	"_test",
+	"_spec"
+];
+const TEST_CLASS_NAME_SUFFIXES = [
+	"Test",
+	"Tests",
+	"Spec"
+];
+const TEST_FILE_NAME_PREFIX = "test_";
+const withoutExtension = (fileName) => {
+	const dot = fileName.lastIndexOf(".");
+	return dot <= 0 ? fileName : fileName.slice(0, dot);
+};
+const isTestFileName = (fileName) => {
+	const name = withoutExtension(fileName);
+	const lowercaseName = name.toLowerCase();
+	return lowercaseName.startsWith(TEST_FILE_NAME_PREFIX) || TEST_FILE_NAME_SUFFIXES.some((suffix) => lowercaseName.endsWith(suffix)) || TEST_CLASS_NAME_SUFFIXES.some((suffix) => name.endsWith(suffix));
+};
+const isTestFile = (displayPath) => {
+	const segments = displayPath.split("/");
+	const fileName = segments[segments.length - 1] ?? "";
+	return segments.slice(0, -1).some((directory) => TEST_DIRECTORY_NAMES.has(directory.toLowerCase())) || isTestFileName(fileName);
+};
+//#endregion
+//#region src/scan/code-references.ts
+const RE_EXPORT_STEPS_FOLLOWED = 2;
+const byTokenIndex = (first, second) => first.tokenIndex - second.tokenIndex;
+const matchesIn = (file, code, callShapes, projectKeys, constantNameOfToken) => {
+	const callMatches = callShapes.length === 0 ? [] : sdkCallMatches(code, callShapes);
+	const keyTokensOfCalls = new Set(callMatches.flatMap((match) => match.kind === "direct" ? [match.tokenIndex] : []));
+	const isTest = isTestFile(file.displayPath);
+	const textMatches = knownKeyTextsIn(code, projectKeys, keyTokensOfCalls).map((text) => ({
+		tokenIndex: text.tokenIndex,
+		kind: "indirect",
+		reference: {
+			key: text.key,
+			line: code.lineOf(text.tokenIndex),
+			test: isTest
+		},
+		constantName: constantNameOfToken.get(text.tokenIndex)
+	}));
+	return [...callMatches, ...textMatches].sort(byTokenIndex);
+};
+const matchOutcomes = (matches, constantIndex) => {
+	const constantsReadByCalls = new Set(matches.flatMap((match) => match.kind === "named" && constantIndex.keyOf(match.name) !== void 0 ? [match.name] : []));
+	return matches.map(({ file, ...match }) => {
+		switch (match.kind) {
+			case "direct": return {
+				file,
+				kind: "direct",
+				reference: match.reference
+			};
+			case "dynamic": return {
+				file,
+				kind: "dynamic",
+				reference: match.reference
+			};
+			case "named": {
+				const key = constantIndex.keyOf(match.name);
+				return key === void 0 ? {
+					file,
+					kind: "dynamic",
+					reference: dynamicReferenceOf(match.reference)
+				} : {
+					file,
+					kind: "direct",
+					reference: {
+						...match.reference,
+						key
+					}
+				};
+			}
+			case "indirect": return match.constantName !== void 0 && constantsReadByCalls.has(match.constantName) ? {
+				file,
+				kind: "definitionOfConstantRead"
+			} : {
+				file,
+				kind: "indirect",
+				reference: match.reference
+			};
+		}
+	});
+};
+const holdsImportMarkerOf = (contents, family) => {
+	const { importMarkers, providerPackagesContainingMarkers = [] } = sdkFamilies[family];
+	const contentsWithoutProviderPackages = providerPackagesContainingMarkers.reduce((text, providerPackage) => text.replaceAll(providerPackage, ""), contents);
+	return importMarkers.some((marker) => contentsWithoutProviderPackages.includes(marker));
+};
+const familiesWithMarkerIn = (contents, families) => families.filter((family) => holdsImportMarkerOf(contents, family));
+const callsAnyOf = (code, families) => {
+	const callNames = new Set(families.flatMap((family) => sdkFamilies[family].calls.map((shape) => shape.name)));
+	return code.tokens.some((token) => token.kind === "identifier" && callNames.has(token.text));
+};
+const familiesOfExtension = (extension) => allSdkFamilies.filter((family) => sdkFamilies[family].extensions.includes(extension));
+const readReachedFile = async (path, localImports) => {
+	const extension = extname(path);
+	const contents = await readFileWithinSizeLimit(path);
+	if (contents === void 0 || !isSourceExtension(extension)) return {
+		kind: "unmarked",
+		reExportedFiles: []
+	};
+	const families = familiesWithMarkerIn(contents, familiesOfExtension(extension));
+	if (families.length > 0) return {
+		kind: "marked",
+		families
+	};
+	return {
+		kind: "unmarked",
+		reExportedFiles: await localImports.filesReExportedBy(new SourceCode(contents, languageOfExtension[extension]), path)
+	};
+};
+const sdkFamiliesUsedIn = (highestDirectory) => {
+	const projectAreas = new ProjectAreas(highestDirectory);
+	const localImports = new LocalImports(highestDirectory);
+	const reachedFileOfPath = /* @__PURE__ */ new Map();
+	const familiesMarkedInPackageOrTargetOfFile = /* @__PURE__ */ new Map();
+	const reachedFileAt = (path) => {
+		const reachedFileReadBefore = reachedFileOfPath.get(path);
+		if (reachedFileReadBefore !== void 0) return reachedFileReadBefore;
+		const reachedFileRead = readReachedFile(path, localImports);
+		reachedFileOfPath.set(path, reachedFileRead);
+		return reachedFileRead;
+	};
+	const familiesReachedThrough = async (path, reExportStepsLeft) => {
+		const reachedFile = await reachedFileAt(path);
+		switch (reachedFile.kind) {
+			case "marked": return reachedFile.families;
+			case "unmarked": {
+				const reExportedFiles = reExportStepsLeft === 0 ? [] : reachedFile.reExportedFiles;
+				return (await Promise.all(reExportedFiles.map((reExportedFile) => familiesReachedThrough(reExportedFile, reExportStepsLeft - 1)))).flat();
+			}
+		}
+	};
+	const familiesMarkedThroughImports = async (file, code) => {
+		const importedPaths = await localImports.filesImportedBy(code, file.path);
+		return (await Promise.all(importedPaths.map((importedPath) => familiesReachedThrough(importedPath, RE_EXPORT_STEPS_FOLLOWED)))).flat();
+	};
+	const familiesMarkedInSamePackageOrTarget = async (file, code) => {
+		const familiesFoundBefore = familiesMarkedInPackageOrTargetOfFile.get(file.path);
+		if (familiesFoundBefore !== void 0) return familiesFoundBefore;
+		const filesOfPackageOrTarget = await localImports.filesOfSamePackageOrTarget(code, file.path);
+		const families = Promise.all(filesOfPackageOrTarget.map((fileOfPackageOrTarget) => familiesReachedThrough(fileOfPackageOrTarget, RE_EXPORT_STEPS_FOLLOWED))).then((familiesOfFiles) => familiesOfFiles.flat());
+		for (const fileOfPackageOrTarget of filesOfPackageOrTarget) familiesMarkedInPackageOrTargetOfFile.set(fileOfPackageOrTarget, families);
+		return families;
+	};
+	const familiesMarkedByOtherFiles = async (file, code) => [...await familiesMarkedThroughImports(file, code), ...await familiesMarkedInSamePackageOrTarget(file, code)];
+	return async (file, code) => {
+		const familiesForExtension = familiesOfExtension(file.extension);
+		const markedHere = familiesWithMarkerIn(file.contents, familiesForExtension);
+		const markedByOtherFiles = callsAnyOf(code, familiesForExtension.filter((family) => !markedHere.includes(family))) ? await familiesMarkedByOtherFiles(file, code) : [];
+		const usedFamilies = [];
+		for (const family of familiesForExtension) {
+			const requiredArea = sdkFamilies[family].projectArea;
+			if ((markedHere.includes(family) || markedByOtherFiles.includes(family)) && (requiredArea === void 0 || await projectAreas.contain(requiredArea, file.path))) usedFamilies.push(family);
+		}
+		return usedFamilies;
+	};
+};
+const scanCodeReferences = async (scope, projectKeys) => {
+	const scan = {
+		filesScanned: 0,
+		references: [],
+		dynamicReferences: []
+	};
+	const familiesUsedIn = sdkFamiliesUsedIn(scope.workingDirectory);
+	const constantIndex = new ConstantIndex();
+	const matches = [];
+	for await (const file of scannedFiles(scope)) {
+		scan.filesScanned += 1;
+		const code = new SourceCode(file.contents, languageOfExtension[file.extension]);
+		const callShapes = (await familiesUsedIn(file, code)).flatMap((sdk) => sdkFamilies[sdk].calls.map((shape) => ({
+			sdk,
+			shape
+		})));
+		const constantAssignments = constantAssignmentsIn(code);
+		for (const assignment of constantAssignments) constantIndex.add(assignment);
+		const constantNameOfToken = new Map(constantAssignments.map((assignment) => [assignment.tokenIndex, assignment.name]));
+		matches.push(...matchesIn(file, code, callShapes, projectKeys, constantNameOfToken).map((match) => ({
+			...match,
+			file: file.displayPath
+		})));
+	}
+	for (const outcome of matchOutcomes(matches, constantIndex)) switch (outcome.kind) {
+		case "direct":
+			scan.references.push({
+				...outcome.reference,
+				kind: "direct",
+				file: outcome.file
+			});
+			break;
+		case "indirect":
+			scan.references.push({
+				...outcome.reference,
+				kind: "indirect",
+				file: outcome.file
+			});
+			break;
+		case "dynamic":
+			scan.dynamicReferences.push({
+				...outcome.reference,
+				file: outcome.file
+			});
+			break;
+		case "definitionOfConstantRead": break;
+	}
+	return scan;
+};
+//#endregion
+//#region src/project-scan.ts
+const scanProject = async (context, path) => {
+	const { workingDirectory } = context.invocation;
+	const settings = await readProjectSettings(workingDirectory);
+	const projectSlug = requireLinkedProjectSlug(context, settings);
+	const root = await scanRootAt(workingDirectory, path);
+	const client = new AdminApiClient({
+		baseUrl: context.baseUrl,
+		token: await configuredApiToken(context)
+	});
+	const project = await findProjectBySlug(client, projectSlug);
+	const configs = await client.listConfigs(project.id);
+	const projectKeys = new Set(configs.flatMap((config) => [config.key, ...config.deprecatedKeys.map((deprecatedKey) => deprecatedKey.key)]));
+	const codeReferenceScan = await scanCodeReferences({
+		root,
+		workingDirectory,
+		include: settings?.include ?? "everyFile",
+		exclude: settings?.exclude ?? []
+	}, projectKeys);
+	return {
+		project,
+		configs,
+		ignoredKeys: new Set(settings?.ignoreKeys ?? []),
+		scannedLocation: root.description,
+		codeReferenceScan
+	};
+};
+//#endregion
+//#region src/commands/scan.ts
+const referenceJson = (reference) => {
+	switch (reference.kind) {
+		case "direct": return {
+			key: reference.key,
+			file: reference.file,
+			line: reference.line,
+			kind: reference.kind,
+			sdk: reference.sdk,
+			call: reference.call,
+			...reference.argument === void 0 ? {} : { argument: reference.argument },
+			...reference.inCodeDefault === void 0 ? {} : { default: reference.inCodeDefault },
+			...reference.getterType === void 0 ? {} : { getterType: reference.getterType },
+			test: reference.test
+		};
+		case "indirect": return {
+			key: reference.key,
+			file: reference.file,
+			line: reference.line,
+			kind: reference.kind,
+			test: reference.test
+		};
+	}
+};
+const scanJson = (projectSlug, scan) => ({
+	project: projectSlug,
+	filesScanned: scan.filesScanned,
+	references: scan.references.map(referenceJson),
+	dynamicReferences: scan.dynamicReferences.map((reference) => ({
+		file: reference.file,
+		line: reference.line,
+		sdk: reference.sdk,
+		call: reference.call,
+		argument: reference.argument
+	}))
+});
+const DYNAMIC_REFERENCES_HEADING = "Dynamic references (calls whose key is not a string literal)";
+const withCollapsedWhitespace = (text) => {
+	let collapsed = "";
+	let previousWasWhitespace = false;
+	for (const character of text) {
+		const isWhitespace = character.trim() === "";
+		if (!isWhitespace) collapsed += character;
+		else if (!previousWasWhitespace) collapsed += " ";
+		previousWasWhitespace = isWhitespace;
+	}
+	return collapsed;
+};
+const describeReference = (reference) => {
+	switch (reference.kind) {
+		case "direct": return `${reference.argument === void 0 ? reference.call : `${reference.call}(${reference.argument})`} (${reference.test ? `${reference.sdk}, test` : reference.sdk})`;
+		case "indirect": return reference.test ? "(indirect, test)" : "(indirect)";
+	}
+};
+const nothingToScanText = (scannedLocation) => `No source files to scan in ${scannedLocation}.\n`;
+const scanText = (scan, scannedLocation) => {
+	if (scan.filesScanned === 0) return nothingToScanText(scannedLocation);
+	const referencesByKey = /* @__PURE__ */ new Map();
+	for (const reference of scan.references) {
+		const referencesToKey = referencesByKey.get(reference.key);
+		if (referencesToKey === void 0) referencesByKey.set(reference.key, [reference]);
+		else referencesToKey.push(reference);
+	}
+	const keySections = [...referencesByKey.keys()].sort().map((key) => [key, ...(referencesByKey.get(key) ?? []).map((reference) => `  ${reference.file}:${reference.line} ${describeReference(reference)}`)].join("\n"));
+	const dynamicSection = scan.dynamicReferences.length === 0 ? [] : [[DYNAMIC_REFERENCES_HEADING, ...scan.dynamicReferences.map((reference) => `  ${reference.file}:${reference.line} ${reference.call}(${withCollapsedWhitespace(reference.argument)}) (${reference.sdk})`)].join("\n")];
+	const directCount = scan.references.filter((reference) => reference.kind === "direct").length;
+	const counts = `${directCount} direct, ${scan.references.length - directCount} indirect and ${scan.dynamicReferences.length} dynamic references in ${scan.filesScanned} scanned ${plural(scan.filesScanned, "file", "files")}.`;
+	return `${[
+		...keySections,
+		...dynamicSection,
+		counts
+	].join("\n\n")}\n`;
+};
+const scan = async (context, [path]) => {
+	const { project, scannedLocation, codeReferenceScan } = await scanProject(context, path);
+	return {
+		json: scanJson(project.slug, codeReferenceScan),
+		text: scanText(codeReferenceScan, scannedLocation),
+		exitCode: ExitCode.success
+	};
+};
+//#endregion
+//#region src/validate/findings.ts
+const servedValueTypesOfConfigTypes = new Map([
+	["boolean", "boolean"],
+	["string", "string"],
+	["url", "string"],
+	["integer", "integer"],
+	["float", "float"],
+	["timespan", "float"],
+	["json", "json"]
+]);
+const servedValueTypesReadableAs = {
+	boolean: ["boolean"],
+	string: [
+		"string",
+		"string-enum",
+		"number-enum"
+	],
+	integer: [
+		"integer",
+		"float",
+		"number-enum"
+	],
+	float: ["float", "number-enum"],
+	number: [
+		"integer",
+		"float",
+		"number-enum"
+	],
+	json: ["json"]
+};
+const servedValueTypesOfEnumValueTypes = new Map([["string", "string-enum"], ["number", "number-enum"]]);
+const isServedTo = {
+	client: (config) => config.client,
+	server: (config) => config.server
+};
+const keyMatchesOfConfigs = (configs) => new Map(configs.flatMap((config) => [[config.key, {
+	kind: "currentKey",
+	config
+}], ...config.deprecatedKeys.map((deprecatedKey) => [deprecatedKey.key, {
+	kind: "deprecatedKey",
+	config
+}])]));
+const typesReadBy = (reference) => [...reference.getterType === void 0 ? [] : [reference.getterType], ...reference.inCodeDefault === void 0 ? [] : [reference.inCodeDefault.type]];
+const servedValueTypeOf = (config) => isEnumConfig(config) ? servedValueTypesOfEnumValueTypes.get(config.typeOptions.valueType) : servedValueTypesOfConfigTypes.get(config.type);
+const isAllowedValue = (inCodeDefault, allowedValues) => {
+	switch (inCodeDefault.type) {
+		case "string": return allowedValues.includes(inCodeDefault.value);
+		case "integer":
+		case "float": return allowedValues.some((allowedValue) => Number(allowedValue) === inCodeDefault.value);
+		case "boolean":
+		case "json": return false;
+	}
+};
+const valueFindings = (reference, config) => {
+	const servedValueType = servedValueTypeOf(config);
+	if (servedValueType === void 0) return [];
+	const typeReadMismatch = typesReadBy(reference).find((typeRead) => !servedValueTypesReadableAs[typeRead].includes(servedValueType));
+	if (typeReadMismatch !== void 0) return [{
+		kind: "type-mismatch",
+		reference,
+		typeRead: typeReadMismatch,
+		configType: config.type,
+		servedAs: servedValueType
+	}];
+	const { inCodeDefault } = reference;
+	if (!isEnumConfig(config) || inCodeDefault === void 0) return [];
+	const allowedValues = config.typeOptions.values;
+	return isAllowedValue(inCodeDefault, allowedValues) ? [] : [{
+		kind: "enum-value-not-allowed",
+		reference,
+		inCodeDefault,
+		allowedValues
+	}];
+};
+const availabilityFindings = (reference, config) => {
+	const { sdkType } = sdkFamilies[reference.sdk];
+	if (reference.test || isServedTo[sdkType](config)) return [];
+	return [{
+		kind: "availability-mismatch",
+		reference,
+		sdkType,
+		configAvailableTo: sdkTypes.filter((servedSdkType) => isServedTo[servedSdkType](config))
+	}];
+};
+const configFindings = (reference, config) => [...valueFindings(reference, config), ...availabilityFindings(reference, config)];
+const findingsOfReference = (reference, keyMatch) => {
+	switch (keyMatch.kind) {
+		case "currentKey": return configFindings(reference, keyMatch.config);
+		case "deprecatedKey": return [{
+			kind: "deprecated-key",
+			reference,
+			currentKey: keyMatch.config.key
+		}, ...configFindings(reference, keyMatch.config)];
+		case "unknownKey": return [{
+			kind: "unknown-key",
+			reference
+		}];
+	}
+};
+const checkCodeReferences = (references, configs, ignoredKeys) => {
+	const keyMatches = keyMatchesOfConfigs(configs);
+	const checkedReferences = references.filter((reference) => reference.kind === "direct" && !ignoredKeys.has(reference.key));
+	return {
+		referencesChecked: checkedReferences.length,
+		findings: checkedReferences.flatMap((reference) => findingsOfReference(reference, keyMatches.get(reference.key) ?? { kind: "unknownKey" }))
+	};
+};
+//#endregion
+//#region src/commands/validate.ts
+const SERVED_VALUE_TYPE_NAMES = {
+	boolean: "a boolean",
+	string: "a string",
+	integer: "an integer",
+	float: "a float",
+	json: "JSON",
+	"string-enum": "strings",
+	"number-enum": "numbers"
+};
+const CONFIG_TYPES_SERVED_AS_THEMSELVES = new Set([
+	"boolean",
+	"string",
+	"integer",
+	"float",
+	"json"
+]);
+const describeAvailability = (configAvailableTo) => {
+	const [onlySdkType] = configAvailableTo;
+	return onlySdkType === void 0 ? "served to no SDK" : `${onlySdkType}-only`;
+};
+const describeInCodeDefault = (inCodeDefault) => inCodeDefault.type === "string" ? JSON.stringify(inCodeDefault.value) : String(inCodeDefault.value);
+const describeConfigType = (configType, servedAs) => CONFIG_TYPES_SERVED_AS_THEMSELVES.has(configType) ? configType : `${configType}, served as ${SERVED_VALUE_TYPE_NAMES[servedAs]}`;
+const FINDING_PRESENTATIONS = {
+	"unknown-key": {
+		heading: "Unknown keys",
+		facts: () => ({}),
+		description: (_finding, projectSlug) => `no config in ${projectSlug} has this key.`
+	},
+	"deprecated-key": {
+		heading: "Deprecated keys",
+		facts: (finding) => ({ currentKey: finding.currentKey }),
+		description: (finding) => `the config was renamed to ${finding.currentKey}.`
+	},
+	"type-mismatch": {
+		heading: "Type mismatches",
+		facts: (finding) => ({
+			configType: finding.configType,
+			servedAs: finding.servedAs,
+			...finding.reference.inCodeDefault === void 0 ? {} : { default: finding.reference.inCodeDefault },
+			...finding.reference.getterType === void 0 ? {} : { getterType: finding.reference.getterType }
+		}),
+		description: (finding) => `read as ${finding.typeRead}, but the config's type is ${describeConfigType(finding.configType, finding.servedAs)}.`
+	},
+	"availability-mismatch": {
+		heading: "Availability mismatches",
+		facts: (finding) => ({
+			sdk: finding.reference.sdk,
+			sdkType: finding.sdkType,
+			configAvailableTo: finding.configAvailableTo
+		}),
+		description: (finding) => `read from a ${finding.sdkType} SDK (${finding.reference.sdk}), but the config is ${describeAvailability(finding.configAvailableTo)}.`
+	},
+	"enum-value-not-allowed": {
+		heading: "Enum values not allowed",
+		facts: (finding) => ({
+			default: finding.inCodeDefault,
+			allowedValues: finding.allowedValues
+		}),
+		description: (finding) => `${describeInCodeDefault(finding.inCodeDefault)} is not one of the allowed values: ${finding.allowedValues.join(", ")}.`
+	}
+};
+const presentationOf = (finding) => FINDING_PRESENTATIONS[finding.kind];
+const findingJson = (finding) => ({
+	kind: finding.kind,
+	key: finding.reference.key,
+	file: finding.reference.file,
+	line: finding.reference.line,
+	...presentationOf(finding).facts(finding)
+});
+const findingLine = (finding, projectSlug) => `  ${finding.reference.file}:${finding.reference.line} ${finding.reference.key}: ` + presentationOf(finding).description(finding, projectSlug);
+const countsText = (scan, check) => {
+	const findingCount = check.findings.length;
+	const problems = findingCount === 0 ? "no problems" : `${findingCount} ${plural(findingCount, "problem", "problems")}`;
+	const checked = `Checked ${check.referencesChecked} direct ${plural(check.referencesChecked, "reference", "references")} in ${scan.filesScanned} scanned ${plural(scan.filesScanned, "file", "files")} and found ${problems}.`;
+	const dynamicCount = scan.dynamicReferences.length;
+	return dynamicCount === 0 ? checked : `${checked} ${dynamicCount} dynamic ${plural(dynamicCount, "reference was", "references were")} not checked.`;
+};
+const validateText = (projectSlug, scan, scannedLocation, check) => {
+	if (scan.filesScanned === 0) return nothingToScanText(scannedLocation);
+	return `${[...Object.keys(FINDING_PRESENTATIONS).flatMap((kind) => {
+		const findingsOfKind = check.findings.filter((finding) => finding.kind === kind);
+		return findingsOfKind.length === 0 ? [] : [[FINDING_PRESENTATIONS[kind].heading, ...findingsOfKind.map((finding) => findingLine(finding, projectSlug))].join("\n")];
+	}), countsText(scan, check)].join("\n\n")}\n`;
+};
+const validate = async (context, [path]) => {
+	const { project, configs, ignoredKeys, scannedLocation, codeReferenceScan } = await scanProject(context, path);
+	const check = checkCodeReferences(codeReferenceScan.references, configs, ignoredKeys);
+	return {
+		json: {
+			...scanJson(project.slug, codeReferenceScan),
+			findings: check.findings.map(findingJson)
+		},
+		text: validateText(project.slug, codeReferenceScan, scannedLocation, check),
+		exitCode: check.findings.length === 0 ? ExitCode.success : ExitCode.problemsFound
+	};
+};
+//#endregion
+//#region src/run.ts
+const DEFAULT_BASE_URL = "https://api.configdirector.com";
+const withoutTrailingSlashes = (url) => {
+	let trimmedUrl = url;
+	while (trimmedUrl.endsWith("/")) trimmedUrl = trimmedUrl.slice(0, -1);
+	return trimmedUrl;
+};
+const runCommand = async (invocation, command, actionArguments) => {
+	const parsedCommand = actionArguments.at(-1);
+	const options = parsedCommand.optsWithGlobals();
+	const output = await command({
+		invocation,
+		baseUrl: withoutTrailingSlashes(options.baseUrl ?? nonEmptyVariable(invocation, "CONFIGDIRECTOR_BASE_URL") ?? DEFAULT_BASE_URL),
+		tokenOption: options.token,
+		projectSlug: options.project ?? nonEmptyVariable(invocation, "CONFIGDIRECTOR_PROJECT")
+	}, parsedCommand.processedArgs);
+	invocation.stdout.write(options.json ? `${JSON.stringify(output.json, null, 2)}\n` : output.text);
+	return output.exitCode;
+};
+const reportFailure = (invocation, error) => {
+	if (error instanceof CommanderError) return error.exitCode === 0 ? ExitCode.success : ExitCode.couldNotRun;
+	if (error instanceof CliError) {
+		invocation.stderr.write(`Error: ${error.message}\n`);
+		return ExitCode.couldNotRun;
+	}
+	invocation.stderr.write(`${error instanceof Error ? error.stack : String(error)}\n`);
+	return ExitCode.couldNotRun;
+};
+const run = async (invocation) => {
+	let exitCode = ExitCode.success;
+	const commandAction = (command) => async (...actionArguments) => {
+		exitCode = await runCommand(invocation, command, actionArguments);
+	};
+	const program = new Command("configdirector").description("Work with ConfigDirector configs from the terminal and CI.").addHelpText("afterAll", "\nBeta: commands and output may change before 1.0.").configureHelp({ showGlobalOptions: true }).version(version).option("--token <token>", "API token, used instead of CONFIGDIRECTOR_TOKEN and the token saved by login").option("--base-url <url>", `Admin API host, used instead of CONFIGDIRECTOR_BASE_URL (default ${DEFAULT_BASE_URL})`).option("--project <slug>", "project slug, used instead of CONFIGDIRECTOR_PROJECT").option("--json", "print JSON on stdout").exitOverride().configureOutput({
+		writeOut: (text) => invocation.stdout.write(text),
+		writeErr: (text) => invocation.stderr.write(text)
+	});
+	program.command("login").description("save an API token for later runs, after checking it can list projects").action(commandAction(login));
+	program.command("init").description("write configdirector.json for a project in the current directory").action(commandAction(init));
+	program.command("scan").argument("[path]", "directory or file to scan (default: the current directory)").description("list where the code reads config keys through a ConfigDirector SDK").action(commandAction(scan));
+	program.command("validate").argument("[path]", "directory or file to check (default: the current directory)").description("check every config key the code reads against the project's configs, exiting 1 when one is wrong").action(commandAction(validate));
+	try {
+		await program.parseAsync(invocation.commandLineArguments, { from: "user" });
+		return exitCode;
+	} catch (error) {
+		return reportFailure(invocation, error);
+	}
+};
+//#endregion
+//#region src/main.ts
+process.exitCode = await run({
+	commandLineArguments: process.argv.slice(2),
+	environmentVariables: process.env,
+	workingDirectory: process.cwd(),
+	homeDirectory: homedir(),
+	platform: process.platform,
+	stdin: process.stdin,
+	stdout: process.stdout,
+	stderr: process.stderr
+});
+//#endregion
+export {};