@pierre/diffs 1.3.0-beta.3 → 1.3.0-beta.4

package/dist/worker/worker-portable.js

@@ -8133,11 +8133,11 @@ var JavaScriptScanner = class {
 	constructor(patterns, options = {}) {
 		this.patterns = patterns;
 		this.options = options;
-		const { forgiving = false, cache, regexConstructor } = options;
+		const { forgiving = false, cache: cache$1, regexConstructor } = options;
 		if (!regexConstructor) throw new Error("Option `regexConstructor` is not provided");
 		this.regexps = patterns.map((p$1) => {
 			if (typeof p$1 !== "string") return p$1;
-			const cached = cache?.get(p$1);
+			const cached = cache$1?.get(p$1);
 			if (cached) {
 				if (cached instanceof RegExp) return cached;
 				if (forgiving) return null;
@@ -8145,10 +8145,10 @@ var JavaScriptScanner = class {
 			}
 			try {
 				const regex = regexConstructor(p$1);
-				cache?.set(p$1, regex);
+				cache$1?.set(p$1, regex);
 				return regex;
 			} catch (e) {
-				cache?.set(p$1, e);
+				cache$1?.set(p$1, e);
 				if (forgiving) return null;
 				throw e;
 			}
@@ -12234,11 +12234,500 @@ function attachResolvedLanguages(resolvedLanguages, highlighter$1) {
 
 //#endregion
 //#region src/highlighter/themes/constants.ts
-const ResolvedThemes = new Map();
-const ResolvingThemes = new Map();
-const RegisteredCustomThemes = new Map();
 const AttachedThemes = new Set();
 
+//#endregion
+//#region ../theming/dist/modules/createThemeCollection.js
+function createThemeCollection(options) {
+	const descriptors = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of getCollectionEntries(options.themes)) {
+		const themes = isThemeCollectionSource(entry) ? entry.getThemes() : [entry];
+		for (const descriptor of themes) {
+			if (seen.has(descriptor.name)) throw new Error(`Theme collection already contains theme "${descriptor.name}"`);
+			seen.add(descriptor.name);
+			descriptors.push(descriptor);
+		}
+	}
+	const allThemes = Object.freeze([...descriptors]);
+	const lightThemes = Object.freeze(allThemes.filter((descriptor) => descriptor.colorScheme === "light"));
+	const darkThemes = Object.freeze(allThemes.filter((descriptor) => descriptor.colorScheme === "dark"));
+	const themesByName = new Map(allThemes.map((descriptor) => [descriptor.name, descriptor]));
+	const allNames = Object.freeze(allThemes.map((descriptor) => descriptor.name));
+	const lightNames = Object.freeze(lightThemes.map((descriptor) => descriptor.name));
+	const darkNames = Object.freeze(darkThemes.map((descriptor) => descriptor.name));
+	function filteredThemes(filterOptions) {
+		if (filterOptions == null) return allThemes;
+		const { colorScheme, collection } = filterOptions;
+		if (collection == null) {
+			if (colorScheme === "light") return lightThemes;
+			if (colorScheme === "dark") return darkThemes;
+			return allThemes;
+		}
+		return allThemes.filter((descriptor) => {
+			if (descriptor.collection !== collection) return false;
+			return colorScheme == null || descriptor.colorScheme === colorScheme;
+		});
+	}
+	return {
+		getTheme(name) {
+			return themesByName.get(name);
+		},
+		getThemes(themeOptions) {
+			return filteredThemes(themeOptions);
+		},
+		getThemeNames(namesOptions) {
+			if (namesOptions?.collection == null) {
+				if (namesOptions?.colorScheme === "light") return lightNames;
+				if (namesOptions?.colorScheme === "dark") return darkNames;
+				return allNames;
+			}
+			return filteredThemes(namesOptions).map((descriptor) => descriptor.name);
+		},
+		hasTheme(name) {
+			return themesByName.has(name);
+		},
+		orderBy(compare) {
+			return createThemeCollection({ themes: allThemes.map((descriptor, index) => ({
+				descriptor,
+				index
+			})).sort((a$1, b$2) => {
+				const result = compare(a$1.descriptor, b$2.descriptor);
+				if (result !== 0) return result;
+				return a$1.index - b$2.index;
+			}).map((entry) => entry.descriptor) });
+		},
+		pick(names) {
+			const picked = [];
+			const pickedNames = /* @__PURE__ */ new Set();
+			for (const name of names) {
+				if (pickedNames.has(name)) throw new Error(`Theme collection pick already includes theme "${name}"`);
+				pickedNames.add(name);
+				const descriptor = themesByName.get(name);
+				if (descriptor == null) throw new Error(`Theme collection does not contain theme "${name}"`);
+				picked.push(descriptor);
+			}
+			return createThemeCollection({ themes: picked });
+		},
+		registerInto(resolver) {
+			for (const descriptor of allThemes) resolver.registerThemeIfAbsent(descriptor.name, descriptor.load);
+		}
+	};
+}
+function getCollectionEntries(input) {
+	if (isThemeCollectionEntry(input)) return [input];
+	return input;
+}
+function isThemeCollectionEntry(input) {
+	return isThemeCollectionSource(input) || isThemeDescriptor(input);
+}
+function isThemeDescriptor(input) {
+	return typeof input.name === "string" && typeof input.load === "function";
+}
+function isThemeCollectionSource(entry) {
+	return typeof entry.getThemes === "function";
+}
+
+//#endregion
+//#region ../theming/dist/modules/createThemeCatalog.js
+function createThemeCatalog(options) {
+	const collection = createThemeCollection({ themes: options.themes });
+	if (!collection.hasTheme(options.defaultLightThemeName)) throw new Error(`Default light theme "${options.defaultLightThemeName}" is not in the catalog`);
+	if (!collection.hasTheme(options.defaultDarkThemeName)) throw new Error(`Default dark theme "${options.defaultDarkThemeName}" is not in the catalog`);
+	return {
+		...collection,
+		defaultLightThemeName: options.defaultLightThemeName,
+		defaultDarkThemeName: options.defaultDarkThemeName
+	};
+}
+
+//#endregion
+//#region ../theming/dist/modules/unwrapDefault.js
+function unwrapDefault(value) {
+	return value !== null && typeof value === "object" && "default" in value ? value.default : value;
+}
+
+//#endregion
+//#region ../theming/dist/modules/createThemeResolver.js
+var DuplicateThemeError = class extends Error {
+	constructor(name) {
+		super(`Theme "${name}" is already registered`);
+		this.name = "DuplicateThemeError";
+	}
+};
+var UnregisteredThemeError = class extends Error {
+	constructor(name) {
+		super(`No loader registered for theme "${name}"`);
+		this.name = "UnregisteredThemeError";
+	}
+};
+var UnresolvedThemeError = class extends Error {
+	constructor(name) {
+		super(`Theme "${name}" has not been resolved`);
+		this.name = "UnresolvedThemeError";
+	}
+};
+function createThemeResolver() {
+	const loaders = /* @__PURE__ */ new Map();
+	const resolved = /* @__PURE__ */ new Map();
+	const inflight = /* @__PURE__ */ new Map();
+	let cacheGeneration = 0;
+	function registerTheme(name, loader) {
+		if (loaders.has(name)) throw new DuplicateThemeError(name);
+		loaders.set(name, loader);
+	}
+	function registerThemeIfAbsent(name, loader) {
+		if (loaders.has(name)) return false;
+		loaders.set(name, loader);
+		return true;
+	}
+	function hasRegisteredTheme(name) {
+		return loaders.has(name);
+	}
+	function resolveTheme(name) {
+		const cached = resolved.get(name);
+		if (cached !== void 0) return Promise.resolve(cached);
+		const existing = inflight.get(name);
+		if (existing !== void 0) return existing;
+		const loader = loaders.get(name);
+		if (loader === void 0) return Promise.reject(new UnregisteredThemeError(name));
+		const generation = cacheGeneration;
+		const promise = loader().then((result) => {
+			const theme = unwrapDefault(result);
+			if (generation === cacheGeneration) resolved.set(name, theme);
+			if (inflight.get(name) === promise) inflight.delete(name);
+			return theme;
+		}).catch((err) => {
+			if (inflight.get(name) === promise) inflight.delete(name);
+			throw err;
+		});
+		inflight.set(name, promise);
+		return promise;
+	}
+	function resolveThemes$1(names) {
+		return Promise.all(names.map((name) => resolveTheme(name)));
+	}
+	function seedResolvedTheme(name, theme) {
+		resolved.set(name, theme);
+	}
+	function seedResolvedThemes(entries) {
+		for (const [name, theme] of entries) seedResolvedTheme(name, theme);
+	}
+	function getResolvedTheme(name) {
+		return resolved.get(name);
+	}
+	function getResolvedThemes(names) {
+		const themes = [];
+		for (const name of names) {
+			const theme = resolved.get(name);
+			if (theme === void 0) throw new UnresolvedThemeError(name);
+			themes.push(theme);
+		}
+		return themes;
+	}
+	function hasResolvedTheme(name) {
+		return resolved.has(name);
+	}
+	function hasResolvedThemes(names) {
+		for (const name of names) if (!resolved.has(name)) return false;
+		return true;
+	}
+	function getResolvedOrResolveTheme(name) {
+		const cached = resolved.get(name);
+		if (cached !== void 0) return cached;
+		return resolveTheme(name);
+	}
+	function clearResolvedThemes() {
+		cacheGeneration++;
+		resolved.clear();
+		inflight.clear();
+	}
+	return {
+		clearResolvedThemes,
+		getResolvedOrResolveTheme,
+		getResolvedTheme,
+		getResolvedThemes,
+		hasRegisteredTheme,
+		hasResolvedTheme,
+		hasResolvedThemes,
+		registerTheme,
+		registerThemeIfAbsent,
+		resolveTheme,
+		resolveThemes: resolveThemes$1,
+		seedResolvedTheme,
+		seedResolvedThemes
+	};
+}
+
+//#endregion
+//#region ../theming/dist/modules/createThemeController.js
+const FALLBACK_LIGHT_THEME = "pierre-light";
+const FALLBACK_DARK_THEME = "pierre-dark";
+function getStorage() {
+	try {
+		if (typeof globalThis !== "undefined" && globalThis.localStorage != null) return globalThis.localStorage;
+	} catch {}
+}
+function createLocalStorageAdapter(storageKey, defaults) {
+	return {
+		load() {
+			const raw$1 = getStorage()?.getItem(storageKey);
+			if (raw$1 == null) return null;
+			try {
+				const parsed = JSON.parse(raw$1);
+				if (parsed.mode == null) return null;
+				return {
+					darkThemeName: parsed.darkThemeName ?? defaults.darkThemeName,
+					lightThemeName: parsed.lightThemeName ?? defaults.lightThemeName,
+					mode: parsed.mode
+				};
+			} catch {
+				return null;
+			}
+		},
+		save(selection) {
+			const storage = getStorage();
+			try {
+				storage?.setItem(storageKey, JSON.stringify(selection));
+			} catch {}
+		}
+	};
+}
+function systemPrefersDark() {
+	try {
+		if (typeof globalThis !== "undefined" && globalThis.matchMedia != null) return globalThis.matchMedia("(prefers-color-scheme: dark)").matches;
+	} catch {}
+	return false;
+}
+function resolveColorScheme(mode) {
+	if (mode === "dark") return "dark";
+	if (mode === "light") return "light";
+	return systemPrefersDark() ? "dark" : "light";
+}
+function createThemeController(options) {
+	const { storageKey, preloadInactive = false } = options;
+	const catalog = "catalog" in options && options.catalog != null ? options.catalog : void 0;
+	const selectedResolver = options.resolver ?? (catalog != null ? createThemeResolver() : void 0);
+	if (selectedResolver == null) throw new Error("createThemeController requires a catalog or resolver");
+	const resolver = selectedResolver;
+	catalog?.registerInto(resolver);
+	const defaultDarkThemeName = options.defaultDarkThemeName ?? catalog?.defaultDarkThemeName ?? FALLBACK_DARK_THEME;
+	const defaultLightThemeName = options.defaultLightThemeName ?? catalog?.defaultLightThemeName ?? FALLBACK_LIGHT_THEME;
+	const persistence = options.persistence ?? (storageKey != null ? createLocalStorageAdapter(storageKey, {
+		darkThemeName: defaultDarkThemeName,
+		lightThemeName: defaultLightThemeName
+	}) : void 0);
+	const initialMode = options.defaultMode ?? "system";
+	let state = {
+		darkThemeName: defaultDarkThemeName,
+		lightThemeName: defaultLightThemeName,
+		mode: initialMode,
+		resolvedTheme: void 0,
+		resolvedColorScheme: resolveColorScheme(initialMode)
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	let activeResolutionId = 0;
+	let pendingSelectionPatch;
+	function notify() {
+		for (const listener of listeners) listener();
+	}
+	function hydrateFromStorage() {
+		const loaded = persistence?.load();
+		if (loaded == null) return;
+		state = {
+			...state,
+			darkThemeName: loaded.darkThemeName,
+			lightThemeName: loaded.lightThemeName,
+			mode: loaded.mode,
+			resolvedColorScheme: resolveColorScheme(loaded.mode)
+		};
+	}
+	function persist() {
+		persistence?.save({
+			darkThemeName: state.darkThemeName,
+			lightThemeName: state.lightThemeName,
+			mode: state.mode
+		});
+	}
+	function activeThemeNameFor(selection) {
+		return selection.resolvedColorScheme === "dark" ? selection.darkThemeName : selection.lightThemeName;
+	}
+	function intendedState(patch = {}) {
+		return {
+			...state,
+			...pendingSelectionPatch,
+			...patch
+		};
+	}
+	function reportResolutionError(error, context) {
+		if (options.onResolutionError != null) {
+			options.onResolutionError(error, context);
+			return;
+		}
+		console.error(`[theming] Failed to resolve theme "${context.name}" for ${context.colorScheme} color scheme`, error);
+	}
+	function preloadInactiveFor(selection) {
+		if (!preloadInactive) return;
+		const activeName = activeThemeNameFor(selection);
+		const inactive = selection.resolvedColorScheme === "dark" ? selection.lightThemeName : selection.darkThemeName;
+		if (inactive !== activeName && resolver.getResolvedTheme(inactive) === void 0) resolver.resolveTheme(inactive).catch(() => {});
+	}
+	function resolveActive(patch = {}, { notifyPending = false, persistOnSuccess = false } = {}) {
+		const selectionPatch = {
+			...pendingSelectionPatch,
+			...patch
+		};
+		const next = intendedState(patch);
+		const name = activeThemeNameFor(next);
+		const colorScheme = next.resolvedColorScheme;
+		const cached = resolver.getResolvedTheme(name);
+		if (cached !== void 0) {
+			activeResolutionId++;
+			pendingSelectionPatch = void 0;
+			state = {
+				...state,
+				...selectionPatch,
+				pendingThemeResolution: void 0,
+				resolutionError: void 0,
+				resolvedTheme: cached
+			};
+			if (persistOnSuccess) persist();
+			notify();
+			preloadInactiveFor(state);
+			return;
+		}
+		const resolutionId = ++activeResolutionId;
+		pendingSelectionPatch = selectionPatch;
+		state = {
+			...state,
+			pendingThemeResolution: {
+				colorScheme,
+				name
+			},
+			resolutionError: void 0
+		};
+		if (notifyPending) notify();
+		resolver.resolveTheme(name).then((theme) => {
+			if (resolutionId !== activeResolutionId) return;
+			const latestIntended = intendedState();
+			if (latestIntended.resolvedColorScheme !== colorScheme || activeThemeNameFor(latestIntended) !== name) return;
+			const patchToCommit = pendingSelectionPatch ?? {};
+			pendingSelectionPatch = void 0;
+			state = {
+				...state,
+				...patchToCommit,
+				pendingThemeResolution: void 0,
+				resolutionError: void 0,
+				resolvedTheme: theme
+			};
+			if (persistOnSuccess) persist();
+			notify();
+			preloadInactiveFor(state);
+		}).catch((error) => {
+			if (resolutionId !== activeResolutionId) return;
+			pendingSelectionPatch = void 0;
+			state = {
+				...state,
+				pendingThemeResolution: void 0,
+				resolutionError: {
+					colorScheme,
+					error,
+					name
+				}
+			};
+			reportResolutionError(error, {
+				colorScheme,
+				name
+			});
+			notify();
+		});
+	}
+	function updateInactiveThemeName(key$1, name) {
+		state = {
+			...state,
+			[key$1]: name,
+			resolutionError: void 0
+		};
+		persist();
+		notify();
+		preloadInactiveFor(state);
+	}
+	function isSchemeActiveInIntendedState(scheme, patch = {}) {
+		return intendedState(patch).resolvedColorScheme === scheme;
+	}
+	function setActiveSelection(patch) {
+		resolveActive(patch, {
+			notifyPending: true,
+			persistOnSuccess: true
+		});
+	}
+	function setInactiveThemeName(scheme, key$1, name) {
+		if (isSchemeActiveInIntendedState(scheme, { [key$1]: name })) setActiveSelection({ [key$1]: name });
+		else updateInactiveThemeName(key$1, name);
+	}
+	function setMode(mode) {
+		setActiveSelection({
+			mode,
+			resolvedColorScheme: resolveColorScheme(mode)
+		});
+	}
+	function maybeUpdateSystemColorScheme() {
+		if (intendedState().mode !== "system") return;
+		const next = resolveColorScheme("system");
+		if (next !== intendedState().resolvedColorScheme) resolveActive({ resolvedColorScheme: next }, { notifyPending: true });
+	}
+	function isSelectedValue(key$1, value) {
+		return intendedState()[key$1] === value;
+	}
+	let mediaQuery;
+	const handleMediaChange = () => {
+		maybeUpdateSystemColorScheme();
+	};
+	function attachMediaListener() {
+		try {
+			if (typeof globalThis !== "undefined" && globalThis.matchMedia != null) {
+				mediaQuery = globalThis.matchMedia("(prefers-color-scheme: dark)");
+				mediaQuery.addEventListener("change", handleMediaChange);
+			}
+		} catch {}
+	}
+	hydrateFromStorage();
+	attachMediaListener();
+	resolveActive();
+	return {
+		resolver,
+		destroy() {
+			if (mediaQuery != null) {
+				mediaQuery.removeEventListener("change", handleMediaChange);
+				mediaQuery = void 0;
+			}
+			listeners.clear();
+		},
+		getState() {
+			return state;
+		},
+		setColorMode(mode) {
+			if (isSelectedValue("mode", mode)) return;
+			setMode(mode);
+		},
+		setThemeNameForScheme(scheme, name) {
+			const key$1 = scheme === "light" ? "lightThemeName" : "darkThemeName";
+			if (isSelectedValue(key$1, name)) return;
+			setInactiveThemeName(scheme, key$1, name);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		}
+	};
+}
+
+//#endregion
+//#region src/highlighter/themes/themeResolver.ts
+const themeResolver = createThemeResolver();
+
 //#endregion
 //#region src/highlighter/themes/attachResolvedThemes.ts
 function attachResolvedThemes(themes, highlighter$1) {
@@ -12246,15 +12735,15 @@ function attachResolvedThemes(themes, highlighter$1) {
 	for (let themeRef of themes) {
 		let resolvedTheme;
 		if (typeof themeRef === "string") {
-			resolvedTheme = ResolvedThemes.get(themeRef);
+			resolvedTheme = themeResolver.getResolvedTheme(themeRef);
 			if (resolvedTheme == null) {
 				throw new Error(`loadResolvedThemes: ${themeRef} is not resolved, you must resolve it before calling loadResolvedThemes`);
 			}
 		} else {
 			resolvedTheme = themeRef;
 			themeRef = themeRef.name;
-			if (!ResolvedThemes.has(themeRef)) {
-				ResolvedThemes.set(themeRef, resolvedTheme);
+			if (themeResolver.getResolvedTheme(themeRef) == null) {
+				themeResolver.seedResolvedTheme(themeRef, resolvedTheme);
 			}
 		}
 		if (AttachedThemes.has(themeRef)) continue;
@@ -15069,30 +15558,234 @@ function formatCSSVariablePrefix(type) {
 	return `--${type === "token" ? "diffs-token" : "diffs"}-`;
 }
 
+//#endregion
+//#region ../theming/dist/modules/color.js
+/**
+* Canonical color/contrast primitives
+*/
+const MIN_READABLE_RATIO = 3;
+const MIN_MUTED_RATIO = 4.5;
+const HEX_TRANSPARENT_RE = /^#(?:[0-9a-f]{3}0|[0-9a-f]{6}00)$/i;
+const ALPHA_ZERO_RE = /^0(?:\.0+)?%?$/;
+function getFunctionalAlpha(color) {
+	const openParen = color.indexOf("(");
+	if (openParen <= 0 || !color.endsWith(")")) return;
+	const fn = color.slice(0, openParen).trim();
+	if (!/^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color)$/i.test(fn)) return;
+	const inner = color.slice(openParen + 1, -1).trim();
+	if (inner.length === 0) return;
+	const slashIndex = inner.lastIndexOf("/");
+	if (slashIndex !== -1) return inner.slice(slashIndex + 1).trim();
+	if (/^(?:rgba|hsla)$/i.test(fn)) {
+		const parts = inner.split(",");
+		if (parts.length === 4) return parts[3]?.trim();
+	}
+}
+function parseHexRgba(color) {
+	const match = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})\b/i.exec(color.trim());
+	if (match == null) return null;
+	const hex = match[1];
+	let expanded;
+	let alpha = 1;
+	if (hex.length === 3) expanded = hex.split("").map((c) => c + c).join("");
+	else if (hex.length === 6) expanded = hex;
+	else {
+		expanded = hex.slice(0, 6);
+		alpha = parseInt(hex.slice(6, 8), 16) / 255;
+	}
+	return [
+		parseInt(expanded.slice(0, 2), 16),
+		parseInt(expanded.slice(2, 4), 16),
+		parseInt(expanded.slice(4, 6), 16),
+		alpha
+	];
+}
+function relativeLuminance(color) {
+	if (color == null) return null;
+	const rgba = parseHexRgba(color);
+	if (rgba == null) return null;
+	const r$3 = rgba[0] / 255;
+	const g = rgba[1] / 255;
+	const b$2 = rgba[2] / 255;
+	const channel = (v$1) => v$1 <= .03928 ? v$1 / 12.92 : ((v$1 + .055) / 1.055) ** 2.4;
+	return .2126 * channel(r$3) + .7152 * channel(g) + .0722 * channel(b$2);
+}
+function contrastRatio(a$1, b$2) {
+	const [hi, lo] = a$1 > b$2 ? [a$1, b$2] : [b$2, a$1];
+	return (hi + .05) / (lo + .05);
+}
+function compositeOverBg(fgColor, bgColor) {
+	if (bgColor == null) return void 0;
+	const fgParts = parseHexRgba(fgColor);
+	const bgParts = parseHexRgba(bgColor);
+	if (fgParts == null || bgParts == null) return void 0;
+	const [fr, fg, fb, fa] = fgParts;
+	const [br, bg, bb] = bgParts;
+	return "#" + [
+		Math.round(fr * fa + br * (1 - fa)),
+		Math.round(fg * fa + bg * (1 - fa)),
+		Math.round(fb * fa + bb * (1 - fa))
+	].map((v$1) => v$1.toString(16).padStart(2, "0")).join("");
+}
+function isFullyTransparent(color) {
+	if (color == null) return false;
+	const normalized = color.trim().toLowerCase();
+	if (normalized === "transparent") return true;
+	if (HEX_TRANSPARENT_RE.test(normalized)) return true;
+	const alpha = getFunctionalAlpha(normalized);
+	return alpha != null && ALPHA_ZERO_RE.test(alpha);
+}
+function isDarkSurface(bg, fgHint) {
+	const fromBg = relativeLuminance(bg);
+	if (fromBg != null) return fromBg < .4;
+	const fromFg = relativeLuminance(fgHint);
+	return fromFg != null ? fromFg > .6 : false;
+}
+function surfacesMatch(a$1, b$2) {
+	if (a$1 == null || b$2 == null) return false;
+	if (a$1.trim().toLowerCase() === b$2.trim().toLowerCase()) return true;
+	const la = relativeLuminance(a$1);
+	const lb = relativeLuminance(b$2);
+	if (la == null || lb == null) return false;
+	return Math.abs(la - lb) < .06;
+}
+function hoverWouldEraseText(hover, bg, fg) {
+	if (bg == null || fg == null) return false;
+	const hoverL = relativeLuminance(hover);
+	const bgL = relativeLuminance(bg);
+	const fgL = relativeLuminance(fg);
+	if (hoverL == null || bgL == null || fgL == null) return false;
+	return Math.abs(hoverL - fgL) < Math.abs(hoverL - bgL);
+}
+function pickReadableForeground(bg, candidates) {
+	const bgL = relativeLuminance(bg);
+	const firstDefined = candidates.find((candidate) => candidate != null && candidate !== "");
+	if (bgL == null) return firstDefined;
+	let best;
+	let bestRatio = -1;
+	for (const candidate of candidates) {
+		if (candidate == null || candidate === "") continue;
+		const candidateL = relativeLuminance(candidate);
+		if (candidateL == null) continue;
+		const ratio = contrastRatio(bgL, candidateL);
+		if (ratio >= MIN_READABLE_RATIO) return candidate;
+		if (ratio > bestRatio) {
+			best = candidate;
+			bestRatio = ratio;
+		}
+	}
+	return best ?? firstDefined;
+}
+function deriveMutedFg(primaryFg, bg) {
+	if (bg == null) return primaryFg;
+	const fgParts = parseHexRgba(primaryFg);
+	const bgParts = parseHexRgba(bg);
+	const bgL = relativeLuminance(bg);
+	if (fgParts == null || bgParts == null || bgL == null) return `color-mix(in srgb, ${primaryFg} 70%, ${bg})`;
+	const [fr, fg2, fb] = fgParts;
+	const [br, bg3, bb] = bgParts;
+	for (const weight of [
+		.6,
+		.7,
+		.8,
+		.9
+	]) {
+		const hex = "#" + [
+			Math.round(fr * weight + br * (1 - weight)),
+			Math.round(fg2 * weight + bg3 * (1 - weight)),
+			Math.round(fb * weight + bb * (1 - weight))
+		].map((v$1) => v$1.toString(16).padStart(2, "0")).join("");
+		const L$2 = relativeLuminance(hex);
+		if (L$2 != null && contrastRatio(bgL, L$2) >= MIN_MUTED_RATIO) return hex;
+	}
+	return primaryFg;
+}
+
+//#endregion
+//#region ../theming/dist/modules/normalizeThemeColors.js
+const cache = /* @__PURE__ */ new WeakMap();
+function normalizeThemeColors(theme) {
+	const cached = cache.get(theme);
+	if (cached != null) return cached;
+	const originalColors = theme.colors ?? {};
+	const colors = { ...originalColors };
+	const editorBackground = originalColors["editor.background"] ?? theme.bg;
+	const editorForeground = originalColors["editor.foreground"] ?? theme.fg;
+	const sidebarBackground = originalColors["sideBar.background"] ?? editorBackground;
+	const sidebarForeground = originalColors["sideBar.foreground"] ?? editorForeground;
+	fill(colors, "editor.background", editorBackground);
+	fill(colors, "editor.foreground", editorForeground);
+	fill(colors, "sideBar.background", sidebarBackground);
+	fill(colors, "sideBar.foreground", sidebarForeground);
+	fill(colors, "input.background", originalColors["input.background"] ?? sidebarBackground);
+	fill(colors, "sideBarSectionHeader.foreground", originalColors["sideBarSectionHeader.foreground"] ?? sidebarForeground);
+	fill(colors, "list.activeSelectionForeground", originalColors["list.activeSelectionForeground"] ?? sidebarForeground);
+	fill(colors, "gitDecoration.addedResourceForeground", firstColor(originalColors["gitDecoration.addedResourceForeground"], originalColors["terminal.ansiGreen"], originalColors["editorGutter.addedBackground"]));
+	fill(colors, "gitDecoration.modifiedResourceForeground", firstColor(originalColors["gitDecoration.modifiedResourceForeground"], originalColors["terminal.ansiBlue"], originalColors["editorGutter.modifiedBackground"]));
+	fill(colors, "gitDecoration.deletedResourceForeground", firstColor(originalColors["gitDecoration.deletedResourceForeground"], originalColors["terminal.ansiRed"], originalColors["editorGutter.deletedBackground"]));
+	const focusRing = (isFullyTransparent(originalColors["list.focusOutline"]) ? void 0 : originalColors["list.focusOutline"]) ?? (isFullyTransparent(originalColors["focusBorder"]) ? void 0 : originalColors["focusBorder"]);
+	if (focusRing != null) colors["list.focusOutline"] = focusRing;
+	else delete colors["list.focusOutline"];
+	const hover = originalColors["list.hoverBackground"];
+	if (hover != null && (matchesSurface(hover, sidebarBackground) || hoverWouldEraseText(hover, sidebarBackground, sidebarForeground))) delete colors["list.hoverBackground"];
+	const result = Object.freeze({
+		...theme,
+		colors: Object.freeze(colors)
+	});
+	cache.set(theme, result);
+	return result;
+}
+function fill(colors, key$1, value) {
+	if (value != null && value !== "") colors[key$1] = value;
+}
+function firstColor(...candidates) {
+	for (const candidate of candidates) if (candidate != null && candidate !== "") return candidate;
+}
+function matchesSurface(color, surface) {
+	return surface != null && color.toLowerCase() === surface.toLowerCase();
+}
+
+//#endregion
+//#region ../theming/dist/color.js
+const colorUtils = {
+	compositeOverBg,
+	contrastRatio,
+	deriveMutedFg,
+	hoverWouldEraseText,
+	isDarkSurface,
+	isFullyTransparent,
+	pickReadableForeground,
+	relativeLuminance,
+	surfacesMatch
+};
+
 //#endregion
 //#region src/utils/getHighlighterThemeStyles.ts
 function getHighlighterThemeStyles({ theme = DEFAULT_THEMES, highlighter: highlighter$1, prefix }) {
 	let styles = "";
 	if (typeof theme === "string") {
 		const themeData = highlighter$1.getTheme(theme);
-		styles += `color:${themeData.fg};`;
-		styles += `background-color:${themeData.bg};`;
-		styles += `${formatCSSVariablePrefix("global")}fg:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, prefix);
+		const normalized = normalizeThemeColors(themeData);
+		styles += `color:${normalized.fg};`;
+		styles += `background-color:${normalized.bg};`;
+		styles += `${formatCSSVariablePrefix("global")}fg:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, prefix);
 	} else {
 		let themeData = highlighter$1.getTheme(theme.dark);
-		styles += `${formatCSSVariablePrefix("global")}dark:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}dark-bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, "dark");
+		let normalized = normalizeThemeColors(themeData);
+		styles += `${formatCSSVariablePrefix("global")}dark:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}dark-bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, "dark");
 		themeData = highlighter$1.getTheme(theme.light);
-		styles += `${formatCSSVariablePrefix("global")}light:${themeData.fg};`;
-		styles += `${formatCSSVariablePrefix("global")}light-bg:${themeData.bg};`;
-		styles += getThemeVariables(themeData, "light");
+		normalized = normalizeThemeColors(themeData);
+		styles += `${formatCSSVariablePrefix("global")}light:${normalized.fg};`;
+		styles += `${formatCSSVariablePrefix("global")}light-bg:${normalized.bg};`;
+		styles += getGitVariables(themeData, "light");
 	}
 	return styles;
 }
-function getThemeVariables(themeData, modePrefix) {
+function getGitVariables(themeData, modePrefix) {
 	modePrefix = modePrefix != null ? `${modePrefix}-` : "";
 	let styles = "";
 	const additionGreen = themeData.colors?.["gitDecoration.addedResourceForeground"] ?? themeData.colors?.["terminal.ansiGreen"];
@@ -15200,6 +15893,18 @@ function hasTrailingContext(fileDiff) {
 	const deletionRemaining = fileDiff.deletionLines.length - (lastHunk.deletionLineIndex + lastHunk.deletionCount);
 	return additionRemaining > 0 || deletionRemaining > 0;
 }
+function hasTrailingContextMismatch(fileDiff) {
+	const lastHunk = fileDiff.hunks[fileDiff.hunks.length - 1];
+	if (lastHunk == null || fileDiff.isPartial || fileDiff.additionLines.length === 0 || fileDiff.deletionLines.length === 0) {
+		return false;
+	}
+	const additionRemaining = fileDiff.additionLines.length - (lastHunk.additionLineIndex + lastHunk.additionCount);
+	const deletionRemaining = fileDiff.deletionLines.length - (lastHunk.deletionLineIndex + lastHunk.deletionCount);
+	if (additionRemaining <= 0 && deletionRemaining <= 0) {
+		return false;
+	}
+	return additionRemaining !== deletionRemaining;
+}
 function getTrailingContextRangeSize({ fileDiff, errorPrefix }) {
 	const lastHunk = fileDiff.hunks[fileDiff.hunks.length - 1];
 	if (lastHunk == null || fileDiff.isPartial || fileDiff.additionLines.length === 0 || fileDiff.deletionLines.length === 0) {