envprism 0.3.0 → 0.3.1

package/dist/chunks/matrix-CG1Msljr.mjs

@@ -0,0 +1,740 @@
+import { readFile, readdir, stat } from "node:fs/promises";
+import consola from "consola";
+import { basename, dirname, join } from "pathe";
+import { existsSync } from "node:fs";
+import { loadConfig } from "c12";
+import { defu } from "defu";
+//#region src/core/mask.ts
+var SECRET_TOKENS = [
+	"SECRET",
+	"TOKEN",
+	"PASSWORD",
+	"PASSWD",
+	"PWD",
+	"KEY",
+	"PRIVATE",
+	"CREDENTIAL",
+	"AUTH",
+	"DSN"
+];
+/**
+* Heuristic: should a value with this key be masked by default? Matches any
+* underscore-separated segment of {@link SECRET_TOKENS} (case-insensitive),
+* with carve-outs for false positives like `*_PUBLIC_KEY`, `PUBLIC_*`, and
+* keys whose final segment is `ID` (e.g. `API_KEY_ID` is an identifier, not
+* a secret).
+*/
+function isSecretKey(key, tokens = SECRET_TOKENS) {
+	const segments = key.toUpperCase().split("_").filter(Boolean);
+	if (segments.length === 0) return false;
+	if (segments[segments.length - 1] === "ID") return false;
+	if (segments[0] === "PUBLIC") return false;
+	if (segments.includes("PUBLIC")) return false;
+	return segments.some((seg) => tokens.some((token) => seg === token || seg.endsWith(token)));
+}
+/**
+* Render a masked placeholder that hints at the original value's length
+* without leaking content. Returns `••••` when the input is empty.
+*/
+function maskValue(value) {
+	if (value.length === 0) return "••••";
+	const dots = "•".repeat(Math.min(value.length, 8));
+	return value.length > 8 ? `${dots} (${value.length})` : dots;
+}
+//#endregion
+//#region src/config/schema.ts
+/**
+* Built-in defaults — the single source of truth for every tunable value.
+* Mirrors the previously hardcoded constants (mask.ts SECRET_TOKENS,
+* format.ts PLACEHOLDER_RE atoms, discover.ts SKIP_SUFFIXES, theme.ts layout).
+*/
+var DEFAULT_CONFIG = {
+	discovery: {
+		paths: ["."],
+		skipSuffixes: [
+			".swp",
+			"~",
+			".bak"
+		],
+		skipSuffixesExtra: [],
+		exampleFirst: true
+	},
+	base: {
+		name: ".env.example",
+		priority: []
+	},
+	heuristics: {
+		secretTokens: [
+			"SECRET",
+			"TOKEN",
+			"PASSWORD",
+			"PASSWD",
+			"PWD",
+			"KEY",
+			"PRIVATE",
+			"CREDENTIAL",
+			"AUTH",
+			"DSN"
+		],
+		secretTokensExtra: [],
+		placeholders: [
+			"todo",
+			"fixme",
+			"changeme",
+			"placeholder",
+			"tbd",
+			"x{3,}",
+			"your[_-]?(secret|key|token|password|api[_-]?key)(_here)?",
+			"replace[_-]?me"
+		],
+		placeholdersExtra: [],
+		grouping: "auto"
+	},
+	diff: {
+		json: false,
+		checkExitCode: 1
+	},
+	tui: {
+		theme: {},
+		layout: {
+			keyColWidth: 22,
+			valueColMin: 18,
+			sidebarWidth: 30,
+			rowGap: 0,
+			cellPadX: 1
+		},
+		undoLimit: 50,
+		maskSecrets: true
+	}
+};
+//#endregion
+//#region src/tui/format.ts
+var PLACEHOLDER_RE = /^(todo|fixme|changeme|placeholder|tbd|x{3,}|your[_-]?(secret|key|token|password|api[_-]?key)(_here)?|replace[_-]?me)$/i;
+function isPlaceholderValue(value, re = PLACEHOLDER_RE) {
+	const v = value.trim();
+	if (v.length === 0) return false;
+	return re.test(v);
+}
+function formatValue(value, secret) {
+	if (value === void 0) return "";
+	if (secret) return maskValue(value);
+	return value;
+}
+function matchesFilter(key, filter) {
+	if (!filter) return true;
+	return key.toLowerCase().includes(filter.toLowerCase());
+}
+function truncate(text, width) {
+	if (width <= 0) return "";
+	if (text.length <= width) return text;
+	if (width <= 1) return "…";
+	return `${text.slice(0, width - 1)}…`;
+}
+function findKvEntry(file, key) {
+	for (const e of file.entries) if (e.kind === "kv" && e.key === key) return e;
+}
+//#endregion
+//#region src/config/resolve.ts
+/** Hex source of truth for the TUI palette (resolved to RGBA in theme.ts). */
+var DEFAULT_THEME_HEX = {
+	fg: "#cccccc",
+	fgDim: "#666666",
+	fgHeader: "#ffffff",
+	fgBase: "#82aaff",
+	fgSection: "#82aaff",
+	differs: "#ffd866",
+	extra: "#ffd866",
+	placeholder: "#ffd866",
+	modified: "#7fce6a",
+	fgDirty: "#7fce6a",
+	missing: "#ff6b6b",
+	focusBg: "#3a3f4b"
+};
+var HEX_RE = /^#[0-9a-fA-F]{6}$/;
+/**
+* Merge user hex overrides onto {@link DEFAULT_THEME_HEX}. Invalid hex values
+* warn (light runtime guard) and fall back to the default. RGBA-free so it is
+* unit-testable under Node without loading the TUI runtime; theme.ts wraps the
+* result with RGBA.fromHex.
+*/
+function resolveThemeHex(theme = {}, warn = consola.warn) {
+	const out = { ...DEFAULT_THEME_HEX };
+	for (const key of Object.keys(DEFAULT_THEME_HEX)) {
+		const override = theme[key];
+		if (override === void 0) continue;
+		if (HEX_RE.test(override)) out[key] = override;
+		else warn(`envprism: ignoring invalid hex for theme.${key}: "${override}"`);
+	}
+	return out;
+}
+/**
+* Resolve a replace-or-extend list field. An explicit `replace` list wins over
+* the built-in `fallback`; `extra` is always appended to whatever the current
+* list is. De-duplicated so repeated entries are harmless.
+*/
+function pickList(replace, extra, fallback) {
+	return [.../* @__PURE__ */ new Set([...replace ?? fallback, ...extra ?? []])];
+}
+/**
+* Merge a deep-partial user config onto {@link DEFAULT_CONFIG}. Scalars and
+* plain objects use defu (user wins, gaps fall back). List fields are handled
+* manually because defu concatenates arrays — wrong for our replace semantics:
+* `*` lists replace the default, `*Extra` lists append. The folded result puts
+* everything into the canonical field and leaves `*Extra` empty.
+*/
+function mergeConfig(user = {}) {
+	return {
+		discovery: {
+			paths: user.discovery?.paths ?? DEFAULT_CONFIG.discovery.paths,
+			skipSuffixes: pickList(user.discovery?.skipSuffixes, user.discovery?.skipSuffixesExtra, DEFAULT_CONFIG.discovery.skipSuffixes),
+			skipSuffixesExtra: [],
+			exampleFirst: user.discovery?.exampleFirst ?? DEFAULT_CONFIG.discovery.exampleFirst
+		},
+		base: {
+			name: user.base?.name ?? DEFAULT_CONFIG.base.name,
+			priority: user.base?.priority ?? DEFAULT_CONFIG.base.priority
+		},
+		heuristics: {
+			secretTokens: pickList(user.heuristics?.secretTokens, user.heuristics?.secretTokensExtra, DEFAULT_CONFIG.heuristics.secretTokens),
+			secretTokensExtra: [],
+			placeholders: pickList(user.heuristics?.placeholders, user.heuristics?.placeholdersExtra, DEFAULT_CONFIG.heuristics.placeholders),
+			placeholdersExtra: [],
+			grouping: user.heuristics?.grouping ?? DEFAULT_CONFIG.heuristics.grouping
+		},
+		diff: defu(user.diff, DEFAULT_CONFIG.diff),
+		tui: {
+			theme: defu(user.tui?.theme, DEFAULT_CONFIG.tui.theme),
+			layout: defu(user.tui?.layout, DEFAULT_CONFIG.tui.layout),
+			undoLimit: user.tui?.undoLimit ?? DEFAULT_CONFIG.tui.undoLimit,
+			maskSecrets: user.tui?.maskSecrets ?? DEFAULT_CONFIG.tui.maskSecrets
+		}
+	};
+}
+/**
+* Compile the resolved heuristics config into ready-to-call matchers. Secret
+* tokens are upper-cased (the matcher upper-cases keys); placeholder atoms are
+* compiled into a single case-insensitive alternation. RGBA-free.
+*/
+function resolveHeuristics(c) {
+	const tokens = c.heuristics.secretTokens.map((t) => t.toUpperCase());
+	const placeholderRe = new RegExp(`^(${c.heuristics.placeholders.join("|")})$`, "i");
+	return {
+		isSecretKey: (key) => isSecretKey(key, tokens),
+		isPlaceholderValue: (value) => isPlaceholderValue(value, placeholderRe),
+		grouping: c.heuristics.grouping
+	};
+}
+//#endregion
+//#region src/config/load.ts
+var CONFIG_EXTS = [
+	"ts",
+	"js",
+	"mjs",
+	"json"
+];
+/**
+* Walk up from `start` looking for envprism.config.{ts,js,mjs,json}. c12 does
+* not climb ancestors itself, so we resolve the file path here and hand it to
+* c12 explicitly. Returns the first match or undefined at the filesystem root.
+*/
+function findConfigUp(start) {
+	let dir = start;
+	for (;;) {
+		for (const ext of CONFIG_EXTS) {
+			const candidate = join(dir, `envprism.config.${ext}`);
+			if (existsSync(candidate)) return candidate;
+		}
+		const parent = dirname(dir);
+		if (parent === dir) return void 0;
+		dir = parent;
+	}
+}
+/**
+* Load and resolve the envprism config. Precedence for *where* to look:
+* explicit `configFile` > `ENVPRISM_CONFIG` env var > walk-up from cwd.
+* c12 handles the walk-up (envprism.config.{ts,js,mjs,json}); we keep
+* rc/global/dotenv off and apply our own merge (defu deep-merges defaults
+* into user lists, which we don't want — see resolve.ts).
+*/
+async function loadEnvprismConfig(options = {}) {
+	const envConfig = process.env.ENVPRISM_CONFIG;
+	const startCwd = options.cwd ?? process.cwd();
+	const resolved = options.configFile ?? envConfig ?? findConfigUp(startCwd);
+	const cwd = resolved ? dirname(resolved) : startCwd;
+	if (!resolved) return {
+		config: mergeConfig({}),
+		configFile: void 0,
+		cwd
+	};
+	const { config } = await loadConfig({
+		name: "envprism",
+		cwd,
+		configFile: resolved,
+		rcFile: false,
+		globalRc: false,
+		dotenv: false
+	});
+	return {
+		config: mergeConfig(config ?? {}),
+		configFile: resolved,
+		cwd
+	};
+}
+//#endregion
+//#region src/core/base.ts
+/**
+* Resolve which {@link EnvFile} acts as the base (reference) for diff. Order:
+*
+* 1. `override` path argument, matched by full path or basename.
+* 2. `options.name` (default `.env.example`) if present.
+* 3. The first file matching `options.priority`, in priority order.
+* 4. The first file (already sorted by {@link discoverEnvFiles}).
+*
+* Returns `null` if `files` is empty.
+*/
+function resolveBase(files, override, options = {}) {
+	if (files.length === 0) return null;
+	if (override) {
+		const match = files.find((f) => f.path === override || basename(f.path) === override);
+		if (!match) throw new Error(`--base ${override} did not match any discovered env file`);
+		return match;
+	}
+	const name = options.name ?? ".env.example";
+	const example = files.find((f) => basename(f.path) === name);
+	if (example) return example;
+	for (const candidate of options.priority ?? []) {
+		const match = files.find((f) => basename(f.path) === candidate);
+		if (match) return match;
+	}
+	return files[0] ?? null;
+}
+//#endregion
+//#region src/core/diff.ts
+var DRIFT_STATES = /* @__PURE__ */ new Set([
+	"differs",
+	"missing",
+	"extra"
+]);
+function computeDiff(matrix) {
+	const files = matrix.files.filter((f) => f !== matrix.base).map((f) => buildFileReport(matrix, f));
+	return {
+		base: matrix.base.path,
+		files,
+		inSync: files.every((f) => f.drift === 0)
+	};
+}
+function buildFileReport(matrix, file) {
+	const keys = {};
+	let drift = 0;
+	for (const key of matrix.keys) {
+		const { state } = matrix.cell(key, file);
+		keys[key] = state;
+		if (DRIFT_STATES.has(state)) drift++;
+	}
+	return {
+		path: file.path,
+		keys,
+		drift
+	};
+}
+function formatDiffText(report) {
+	const baseName = basename(report.base);
+	const otherNames = report.files.map((f) => basename(f.path));
+	const lines = [];
+	lines.push(`Base: ${baseName}  (vs. ${otherNames.join(", ")})`);
+	lines.push("");
+	if (report.files.length === 0) {
+		lines.push("No other env files to compare.");
+		return lines.join("\n") + "\n";
+	}
+	const driftKeys = /* @__PURE__ */ new Set();
+	for (const f of report.files) for (const [k, s] of Object.entries(f.keys)) if (DRIFT_STATES.has(s)) driftKeys.add(k);
+	if (driftKeys.size === 0) {
+		lines.push("All env files are in sync with the base.");
+		return lines.join("\n") + "\n";
+	}
+	const keyWidth = Math.max(3, ...[...driftKeys].map((k) => k.length));
+	const colWidth = Math.max(12, ...otherNames.map((n) => n.length));
+	lines.push(formatRow("KEY", otherNames, keyWidth, colWidth, (n) => n.padEnd(colWidth)));
+	for (const key of [...driftKeys].sort()) {
+		const cells = report.files.map((f) => stateLabel(f.keys[key] ?? "missing"));
+		lines.push(formatRow(key, cells, keyWidth, colWidth, (n) => n.padEnd(colWidth)));
+	}
+	lines.push("");
+	const totalDrift = report.files.reduce((sum, f) => sum + f.drift, 0);
+	lines.push(`${driftKeys.size} key(s) differ across ${report.files.length} file(s) (${totalDrift} cell drift).`);
+	return lines.join("\n") + "\n";
+}
+function formatRow(key, cells, keyWidth, colWidth, pad) {
+	return [key.padEnd(keyWidth), ...cells.map(pad)].join("  ");
+}
+function stateLabel(state) {
+	switch (state) {
+		case "same": return "— same";
+		case "differs": return "≠ differs";
+		case "missing": return "✗ missing";
+		case "extra": return "★ extra";
+		case "base": return "· base";
+	}
+}
+//#endregion
+//#region src/core/parse.ts
+var KEY_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Parse a `.env` file into a structured, round-trippable representation.
+* Each entry stores its original raw line so the serializer can emit it
+* byte-for-byte when nothing changes.
+*/
+function parseEnv(source, path = "") {
+	const trailingNewline = source.endsWith("\n");
+	const body = trailingNewline ? source.slice(0, -1) : source;
+	const lines = body.length === 0 ? [] : body.split("\n");
+	const entries = [];
+	for (const raw of lines) entries.push(parseLine(raw));
+	return {
+		path,
+		entries,
+		trailingNewline
+	};
+}
+function parseLine(raw) {
+	if (raw.trim().length === 0) return {
+		kind: "blank",
+		raw
+	};
+	if (raw.replace(/^\s+/, "").startsWith("#")) return {
+		kind: "comment",
+		raw
+	};
+	const kv = tryParseKv(raw);
+	if (kv) return kv;
+	return {
+		kind: "comment",
+		raw
+	};
+}
+function tryParseKv(raw) {
+	let rest = raw;
+	const leadingWs = rest.match(/^[ \t]*/)?.[0] ?? "";
+	rest = rest.slice(leadingWs.length);
+	let exportPrefix = false;
+	if (rest.startsWith("export ")) {
+		exportPrefix = true;
+		rest = rest.slice(7).replace(/^[ \t]*/, "");
+	}
+	const eqIdx = rest.indexOf("=");
+	if (eqIdx < 0) return null;
+	const key = rest.slice(0, eqIdx).trimEnd();
+	if (!KEY_RE.test(key)) return null;
+	const after = rest.slice(eqIdx + 1);
+	const valueStart = after.replace(/^[ \t]*/, "");
+	after.slice(0, after.length - valueStart.length);
+	const parsed = parseValue(valueStart);
+	if (!parsed) return null;
+	return {
+		kind: "kv",
+		key,
+		rawValue: parsed.rawValue,
+		value: parsed.value,
+		quoting: parsed.quoting,
+		exportPrefix,
+		inlineComment: parsed.inlineComment,
+		raw
+	};
+}
+function parseValue(input) {
+	if (input.length === 0) return {
+		rawValue: "",
+		value: "",
+		quoting: "none",
+		inlineComment: ""
+	};
+	const first = input[0];
+	if (first === "\"" || first === "'") {
+		const close = findClosingQuote(input, first);
+		if (close < 0) return null;
+		const rawValue = input.slice(1, close);
+		const value = first === "\"" ? decodeDoubleQuoted(rawValue) : rawValue;
+		const inlineComment = extractInlineComment(input.slice(close + 1));
+		return {
+			rawValue,
+			value,
+			quoting: first === "\"" ? "double" : "single",
+			inlineComment
+		};
+	}
+	const hashIdx = findUnquotedCommentStart(input);
+	const valuePart = (hashIdx < 0 ? input : input.slice(0, hashIdx)).trimEnd();
+	return {
+		rawValue: valuePart,
+		value: valuePart,
+		quoting: "none",
+		inlineComment: hashIdx < 0 ? "" : input.slice(valuePart.length)
+	};
+}
+function findClosingQuote(input, quote) {
+	for (let i = 1; i < input.length; i++) {
+		const ch = input[i];
+		if (quote === "\"" && ch === "\\") {
+			i++;
+			continue;
+		}
+		if (ch === quote) return i;
+	}
+	return -1;
+}
+function findUnquotedCommentStart(input) {
+	for (let i = 0; i < input.length; i++) {
+		if (input[i] !== "#") continue;
+		if (i === 0) return i;
+		const prev = input[i - 1];
+		if (prev === " " || prev === "	") return i;
+	}
+	return -1;
+}
+function extractInlineComment(tail) {
+	return tail;
+}
+function decodeDoubleQuoted(raw) {
+	return raw.replace(/\\(.)/g, (_, ch) => {
+		switch (ch) {
+			case "n": return "\n";
+			case "r": return "\r";
+			case "t": return "	";
+			case "\\": return "\\";
+			case "\"": return "\"";
+			default: return `\\${ch}`;
+		}
+	});
+}
+//#endregion
+//#region src/core/discover.ts
+var SKIP_SUFFIXES = [
+	".swp",
+	"~",
+	".bak"
+];
+/**
+* Discover `.env*` files in the given path(s). Each path may be a directory
+* (glob-like discovery happens at its top level) or an explicit file. Editor
+* and backup files are skipped.
+*
+* Files are returned sorted: `.env.example` first if present (unless
+* `exampleFirst` is false), then the rest alphabetically. Base-resolution
+* lives in `base.ts` and depends on this order.
+*/
+async function discoverEnvFiles(paths, options = {}) {
+	const skipSuffixes = options.skipSuffixes ?? SKIP_SUFFIXES;
+	const exampleFirst = options.exampleFirst ?? true;
+	const filePaths = /* @__PURE__ */ new Set();
+	for (const p of paths) if ((await stat(p)).isDirectory()) {
+		const entries = await readdir(p);
+		for (const name of entries) {
+			if (!looksLikeEnvFile(name, skipSuffixes)) continue;
+			filePaths.add(join(p, name));
+		}
+	} else filePaths.add(p);
+	const sorted = [...filePaths].sort((a, b) => envPathOrder(a, b, exampleFirst));
+	const files = [];
+	for (const filePath of sorted) {
+		const source = await readFile(filePath, "utf8");
+		files.push(parseEnv(source, filePath));
+	}
+	return files;
+}
+function looksLikeEnvFile(name, skipSuffixes) {
+	if (!name.startsWith(".env")) return false;
+	if (skipSuffixes.some((s) => name.endsWith(s))) return false;
+	return true;
+}
+function envPathOrder(a, b, exampleFirst) {
+	const an = basename(a);
+	const bn = basename(b);
+	if (exampleFirst) {
+		if (an === ".env.example") return -1;
+		if (bn === ".env.example") return 1;
+	}
+	return an.localeCompare(bn);
+}
+//#endregion
+//#region src/core/sections.ts
+var SEP_CHARS = /* @__PURE__ */ new Set([
+	"=",
+	"-",
+	"#",
+	"~",
+	"*"
+]);
+var SPACE_CHARS = /* @__PURE__ */ new Set([" ", "	"]);
+/**
+* Walk the base file in source order and decide which section each kv entry
+* belongs to. Returns a `key → section` map; keys with no inferred section
+* are absent from the map.
+*
+* A "section header" is one of:
+*   1. An inline banner: `# === Section name ===` (or `---`, `~~~`, `***`).
+*   2. A block banner — a single comment line `# Section name` whose
+*      immediately preceding or following comment line is purely decorative
+*      (e.g. `# ===========================`).
+*
+* The detected name applies to every subsequent kv entry until the next
+* detected section header.
+*/
+function computeSections(base) {
+	const out = /* @__PURE__ */ new Map();
+	let current = null;
+	for (let i = 0; i < base.entries.length; i++) {
+		const name = detectSectionName(base.entries, i);
+		if (name !== null) current = name;
+		const e = base.entries[i];
+		if (e.kind === "kv" && current) out.set(e.key, current);
+	}
+	return out;
+}
+function detectSectionName(entries, idx) {
+	const e = entries[idx];
+	if (!e || e.kind !== "comment") return null;
+	if (isDecorativeLine(e.raw)) return null;
+	const inline = parseInlineBanner(e.raw);
+	if (inline !== null) return inline;
+	const text = stripCommentPrefix(e.raw);
+	if (!text) return null;
+	if (isDecorative(entries[idx - 1]) || isDecorative(entries[idx + 1])) return text;
+	return null;
+}
+function isDecorative(e) {
+	if (!e || e.kind !== "comment") return false;
+	return isDecorativeLine(e.raw);
+}
+/**
+* True for comment lines whose body is nothing but separator chars and
+* whitespace (e.g. "# ======", "###", "# -=-=-=-").
+*
+* Implemented with a manual scan rather than a regex with overlapping
+* `\s*` / `[\s…]+` groups, which CodeQL flags as ReDoS-prone.
+*/
+function isDecorativeLine(raw) {
+	const start = skipSpaces(raw, 0);
+	if (start >= raw.length || raw[start] !== "#") return false;
+	let i = start + 1;
+	let sawSeparator = false;
+	while (i < raw.length) {
+		const ch = raw[i];
+		if (SEP_CHARS.has(ch)) sawSeparator = true;
+		else if (!SPACE_CHARS.has(ch)) return false;
+		i++;
+	}
+	return sawSeparator;
+}
+/**
+* Parse a single-line inline banner like `# === Name ===` (also `---`,
+* `~~~`, `***`) and return the inner name, or null if the line isn't an
+* inline banner.
+*
+* Manual scan, again to avoid the overlapping `\s*` regex backtracking
+* CodeQL warned about.
+*/
+function parseInlineBanner(raw) {
+	const start = skipSpaces(raw, 0);
+	if (start >= raw.length || raw[start] !== "#") return null;
+	let i = skipSpaces(raw, start + 1);
+	if (i >= raw.length || !SEP_CHARS.has(raw[i])) return null;
+	let leadCount = 0;
+	while (i < raw.length && SEP_CHARS.has(raw[i])) {
+		leadCount++;
+		i++;
+	}
+	if (leadCount < 2) return null;
+	let j = raw.length;
+	while (j > i && SPACE_CHARS.has(raw[j - 1])) j--;
+	if (j <= i || !SEP_CHARS.has(raw[j - 1])) return null;
+	let trailCount = 0;
+	while (j > i && SEP_CHARS.has(raw[j - 1])) {
+		trailCount++;
+		j--;
+	}
+	if (trailCount < 2) return null;
+	const inner = raw.slice(i, j).trim();
+	return inner.length > 0 ? inner : null;
+}
+function stripCommentPrefix(raw) {
+	let i = skipSpaces(raw, 0);
+	while (i < raw.length && raw[i] === "#") i++;
+	i = skipSpaces(raw, i);
+	let j = raw.length;
+	while (j > i && (SPACE_CHARS.has(raw[j - 1]) || SEP_CHARS.has(raw[j - 1]))) j--;
+	return raw.slice(i, j);
+}
+function skipSpaces(raw, from) {
+	let i = from;
+	while (i < raw.length && SPACE_CHARS.has(raw[i])) i++;
+	return i;
+}
+//#endregion
+//#region src/core/matrix.ts
+function buildMatrix(files, base) {
+	const keys = collectKeys(files, base);
+	const lookups = /* @__PURE__ */ new Map();
+	for (const file of files) lookups.set(file, indexKv(file));
+	const baseIndex = lookups.get(base);
+	if (!baseIndex) throw new Error("base file is not in the files list");
+	const sections = computeSections(base);
+	return {
+		keys,
+		files,
+		base,
+		sectionOf(key) {
+			return sections.get(key);
+		},
+		cell(key, file) {
+			const ownIndex = lookups.get(file);
+			if (!ownIndex) throw new Error(`file not in matrix: ${file.path}`);
+			const own = ownIndex.get(key);
+			const baseEntry = baseIndex.get(key);
+			if (file === base) return {
+				state: own ? "base" : "missing",
+				value: own?.value
+			};
+			if (!own && !baseEntry) return {
+				state: "missing",
+				value: void 0
+			};
+			if (!own) return {
+				state: "missing",
+				value: void 0
+			};
+			if (!baseEntry) return {
+				state: "extra",
+				value: own.value
+			};
+			return {
+				state: own.value === baseEntry.value ? "same" : "differs",
+				value: own.value
+			};
+		}
+	};
+}
+function collectKeys(files, base) {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (const e of base.entries) if (e.kind === "kv" && !seen.has(e.key)) {
+		seen.add(e.key);
+		out.push(e.key);
+	}
+	const extras = /* @__PURE__ */ new Set();
+	for (const file of files) {
+		if (file === base) continue;
+		for (const e of file.entries) if (e.kind === "kv" && !seen.has(e.key)) extras.add(e.key);
+	}
+	for (const k of [...extras].sort()) out.push(k);
+	return out;
+}
+function indexKv(file) {
+	const m = /* @__PURE__ */ new Map();
+	for (const e of file.entries) if (e.kind === "kv") m.set(e.key, e);
+	return m;
+}
+//#endregion
+export { isSecretKey as _, computeDiff as a, loadEnvprismConfig as c, resolveThemeHex as d, findKvEntry as f, DEFAULT_CONFIG as g, truncate as h, parseEnv as i, DEFAULT_THEME_HEX as l, matchesFilter as m, computeSections as n, formatDiffText as o, formatValue as p, discoverEnvFiles as r, resolveBase as s, buildMatrix as t, resolveHeuristics as u, maskValue as v };
+
+//# sourceMappingURL=matrix-CG1Msljr.mjs.map