@ctrl-ui/react 0.8.0

package/dist/lib/color.d.ts

@@ -0,0 +1,72 @@
+//#region src/lib/color.d.ts
+type Hsva = {
+  h: number;
+  s: number;
+  v: number;
+  a: number;
+};
+type Rgba = {
+  r: number;
+  g: number;
+  b: number;
+  a: number;
+};
+type Hsla = {
+  h: number;
+  s: number;
+  l: number;
+  a: number;
+};
+type Oklcha = {
+  L: number;
+  C: number;
+  H: number;
+  a: number;
+};
+type ColorFormat = "hex" | "rgb" | "hsl" | "oklch";
+type ChannelId = "r" | "g" | "b" | "h" | "s" | "l" | "okl" | "okc" | "okh" | "a";
+type ChannelSpec = {
+  id: ChannelId;
+  label: string;
+  value: number;
+  min: number;
+  max: number;
+  step: number;
+};
+declare function hsvaToRgba({ h, s, v, a }: Hsva): Rgba;
+declare function rgbaToHsva({ r, g, b, a }: Rgba): Hsva;
+declare function hsvaToHsla({ h, s, v, a }: Hsva): Hsla;
+declare function hslaToHsva({ h, s, l, a }: Hsla): Hsva;
+declare function rgbaToHsla(rgba: Rgba): Hsla;
+declare function hslaToRgba(hsla: Hsla): Rgba;
+declare function hsvaToOklcha(hsva: Hsva): Oklcha;
+declare function oklchaToHsva({ L, C, H, a }: Oklcha): Hsva;
+declare function hexToRgba(input: string): Rgba | null;
+declare function rgbaToHex(rgba: Rgba, withAlpha?: boolean): string;
+declare function formatColor(hsva: Hsva, format: ColorFormat, opts?: {
+  alpha?: boolean;
+}): string;
+declare function parseColor(input: string): Hsva | null;
+declare function getChannels(hsva: Hsva, format: ColorFormat): ChannelSpec[];
+declare function setChannel(hsva: Hsva, id: ChannelId, value: number): Hsva;
+declare function pointToSaturationValue(rect: {
+  width: number;
+  height: number;
+}, offsetX: number, offsetY: number): {
+  s: number;
+  v: number;
+};
+type GradientKind = "linear" | "radial" | "conic";
+declare function formatGradient(stops: {
+  position: number;
+  color: string;
+}[], type: GradientKind, angle: number): string;
+declare function pointToHueSat(rect: {
+  width: number;
+  height: number;
+}, offsetX: number, offsetY: number): {
+  h: number;
+  s: number;
+};
+//#endregion
+export { ChannelId, ChannelSpec, ColorFormat, GradientKind, Hsla, Hsva, Oklcha, Rgba, formatColor, formatGradient, getChannels, hexToRgba, hslaToHsva, hslaToRgba, hsvaToHsla, hsvaToOklcha, hsvaToRgba, oklchaToHsva, parseColor, pointToHueSat, pointToSaturationValue, rgbaToHex, rgbaToHsla, rgbaToHsva, setChannel };

package/dist/lib/color.js

@@ -0,0 +1,490 @@
+//#region src/lib/color.ts
+const clamp = (n, min, max) => Math.min(max, Math.max(min, n));
+const clamp01 = (n) => clamp(n, 0, 1);
+const wrapHue = (h) => (h % 360 + 360) % 360;
+const round = (n) => Math.round(n);
+function hsvaToRgba({ h, s, v, a }) {
+	const S = clamp01(s / 100);
+	const V = clamp01(v / 100);
+	const c = V * S;
+	const hh = wrapHue(h) / 60;
+	const x = c * (1 - Math.abs(hh % 2 - 1));
+	const m = V - c;
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	if (hh < 1) [r, g, b] = [
+		c,
+		x,
+		0
+	];
+	else if (hh < 2) [r, g, b] = [
+		x,
+		c,
+		0
+	];
+	else if (hh < 3) [r, g, b] = [
+		0,
+		c,
+		x
+	];
+	else if (hh < 4) [r, g, b] = [
+		0,
+		x,
+		c
+	];
+	else if (hh < 5) [r, g, b] = [
+		x,
+		0,
+		c
+	];
+	else [r, g, b] = [
+		c,
+		0,
+		x
+	];
+	return {
+		r: round((r + m) * 255),
+		g: round((g + m) * 255),
+		b: round((b + m) * 255),
+		a: clamp01(a)
+	};
+}
+function rgbaToHsva({ r, g, b, a }) {
+	const R = clamp(r, 0, 255) / 255;
+	const G = clamp(g, 0, 255) / 255;
+	const B = clamp(b, 0, 255) / 255;
+	const max = Math.max(R, G, B);
+	const d = max - Math.min(R, G, B);
+	let h = 0;
+	if (d !== 0) {
+		if (max === R) h = 60 * ((G - B) / d % 6);
+		else if (max === G) h = 60 * ((B - R) / d + 2);
+		else h = 60 * ((R - G) / d + 4);
+	}
+	const s = max === 0 ? 0 : d / max;
+	return {
+		h: wrapHue(h),
+		s: s * 100,
+		v: max * 100,
+		a: clamp01(a)
+	};
+}
+function hsvaToHsla({ h, s, v, a }) {
+	const S = clamp01(s / 100);
+	const V = clamp01(v / 100);
+	const L = V * (1 - S / 2);
+	const Sl = L === 0 || L === 1 ? 0 : (V - L) / Math.min(L, 1 - L);
+	return {
+		h: wrapHue(h),
+		s: Sl * 100,
+		l: L * 100,
+		a: clamp01(a)
+	};
+}
+function hslaToHsva({ h, s, l, a }) {
+	const S = clamp01(s / 100);
+	const L = clamp01(l / 100);
+	const V = L + S * Math.min(L, 1 - L);
+	const Sv = V === 0 ? 0 : 2 * (1 - L / V);
+	return {
+		h: wrapHue(h),
+		s: Sv * 100,
+		v: V * 100,
+		a: clamp01(a)
+	};
+}
+function rgbaToHsla(rgba) {
+	return hsvaToHsla(rgbaToHsva(rgba));
+}
+function hslaToRgba(hsla) {
+	return hsvaToRgba(hslaToHsva(hsla));
+}
+const srgbToLinear = (c) => c <= .04045 ? c / 12.92 : ((c + .055) / 1.055) ** 2.4;
+const linearToSrgb = (c) => c <= .0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - .055;
+function rgbToOklch(r255, g255, b255) {
+	const r = srgbToLinear(clamp(r255, 0, 255) / 255);
+	const g = srgbToLinear(clamp(g255, 0, 255) / 255);
+	const b = srgbToLinear(clamp(b255, 0, 255) / 255);
+	const l = .4122214708 * r + .5363325363 * g + .0514459929 * b;
+	const m = .2119034982 * r + .6806995451 * g + .1073969566 * b;
+	const s = .0883024619 * r + .2817188376 * g + .6299787005 * b;
+	const l_ = Math.cbrt(l);
+	const m_ = Math.cbrt(m);
+	const s_ = Math.cbrt(s);
+	const L = .2104542553 * l_ + .793617785 * m_ - .0040720468 * s_;
+	const A = 1.9779984951 * l_ - 2.428592205 * m_ + .4505937099 * s_;
+	const B = .0259040371 * l_ + .7827717662 * m_ - .808675766 * s_;
+	const C = Math.hypot(A, B);
+	let H = Math.atan2(B, A) * 180 / Math.PI;
+	if (H < 0) H += 360;
+	return {
+		L,
+		C,
+		H
+	};
+}
+function oklchToRgb(L, C, H) {
+	const hr = H * Math.PI / 180;
+	const a = C * Math.cos(hr);
+	const b = C * Math.sin(hr);
+	const l_ = L + .3963377774 * a + .2158037573 * b;
+	const m_ = L - .1055613458 * a - .0638541728 * b;
+	const s_ = L - .0894841775 * a - 1.291485548 * b;
+	const l = l_ ** 3;
+	const m = m_ ** 3;
+	const s = s_ ** 3;
+	const r = 4.0767416621 * l - 3.3077115913 * m + .2309699292 * s;
+	const g = -1.2684380046 * l + 2.6097574011 * m - .3413193965 * s;
+	const bl = -.0041960863 * l - .7034186147 * m + 1.707614701 * s;
+	const to = (c) => clamp(round(linearToSrgb(c) * 255), 0, 255);
+	return {
+		r: to(r),
+		g: to(g),
+		b: to(bl)
+	};
+}
+function hsvaToOklcha(hsva) {
+	const { r, g, b } = hsvaToRgba(hsva);
+	const { L, C, H } = rgbToOklch(r, g, b);
+	return {
+		L,
+		C,
+		H,
+		a: clamp01(hsva.a)
+	};
+}
+function oklchaToHsva({ L, C, H, a }) {
+	const { r, g, b } = oklchToRgb(L, C, H);
+	return rgbaToHsva({
+		r,
+		g,
+		b,
+		a
+	});
+}
+const hex2 = (n) => clamp(round(n), 0, 255).toString(16).padStart(2, "0");
+function hexToRgba(input) {
+	const m = input.trim().replace(/^#/, "");
+	const read = (h) => Number.parseInt(h, 16);
+	if (m.length === 3 || m.length === 4) {
+		if (!/^[0-9a-f]+$/i.test(m)) return null;
+		const [red, green, blue, alpha] = m;
+		if (!red || !green || !blue) return null;
+		return {
+			r: read(red + red),
+			g: read(green + green),
+			b: read(blue + blue),
+			a: alpha ? read(alpha + alpha) / 255 : 1
+		};
+	}
+	if (m.length === 6 || m.length === 8) {
+		if (!/^[0-9a-f]+$/i.test(m)) return null;
+		return {
+			r: read(m.slice(0, 2)),
+			g: read(m.slice(2, 4)),
+			b: read(m.slice(4, 6)),
+			a: m.length === 8 ? read(m.slice(6, 8)) / 255 : 1
+		};
+	}
+	return null;
+}
+function rgbaToHex(rgba, withAlpha = rgba.a < 1) {
+	const base = `#${hex2(rgba.r)}${hex2(rgba.g)}${hex2(rgba.b)}`;
+	return withAlpha ? `${base}${hex2(clamp01(rgba.a) * 255)}` : base;
+}
+const trimNum = (n, d) => n.toFixed(d).replace(/\.?0+$/, "");
+function oklchTriplet(L, C, H) {
+	const Ls = trimNum(L, 4);
+	if (C < 1e-4) return `${Ls} 0 0`;
+	return `${Ls} ${trimNum(C, 4)} ${trimNum(H, 3)}`;
+}
+function formatColor(hsva, format, opts) {
+	const useAlpha = opts?.alpha !== false && hsva.a < 1;
+	const alphaSuffix = useAlpha ? ` / ${trimNum(clamp01(hsva.a), 3)}` : "";
+	switch (format) {
+		case "hex": return rgbaToHex(hsvaToRgba(hsva), useAlpha);
+		case "rgb": {
+			const { r, g, b } = hsvaToRgba(hsva);
+			return `rgb(${r} ${g} ${b}${alphaSuffix})`;
+		}
+		case "hsl": {
+			const { h, s, l } = hsvaToHsla(hsva);
+			return `hsl(${trimNum(wrapHue(h), 1)} ${trimNum(s, 1)}% ${trimNum(l, 1)}%${alphaSuffix})`;
+		}
+		case "oklch": {
+			const { L, C, H } = hsvaToOklcha(hsva);
+			return `oklch(${oklchTriplet(L, C, H)}${alphaSuffix})`;
+		}
+	}
+}
+const NAMED = {
+	transparent: "#00000000",
+	black: "#000000",
+	white: "#ffffff",
+	red: "#ff0000",
+	green: "#008000",
+	blue: "#0000ff",
+	yellow: "#ffff00",
+	orange: "#ffa500",
+	purple: "#800080",
+	gray: "#808080",
+	grey: "#808080"
+};
+function readAlpha(token) {
+	if (token === void 0) return 1;
+	const t = token.trim();
+	if (t.endsWith("%")) return clamp01(Number.parseFloat(t) / 100);
+	return clamp01(Number.parseFloat(t));
+}
+function parseHexColor(raw) {
+	const rgba = hexToRgba(raw);
+	return rgba ? rgbaToHsva(rgba) : null;
+}
+function parseRgbFunction(raw) {
+	const match = raw.match(/^rgba?\(\s*([\d.]+%?)[\s,]+([\d.]+%?)[\s,]+([\d.]+%?)\s*(?:[/,]\s*([\d.]+%?))?\s*\)$/);
+	if (!match) return null;
+	const [, red, green, blue, alpha] = match;
+	if (!red || !green || !blue) return null;
+	const chan = (t) => t.endsWith("%") ? Number.parseFloat(t) / 100 * 255 : Number.parseFloat(t);
+	return rgbaToHsva({
+		r: chan(red),
+		g: chan(green),
+		b: chan(blue),
+		a: readAlpha(alpha)
+	});
+}
+function parseHslFunction(raw) {
+	const match = raw.match(/^hsla?\(\s*([\d.]+)(?:deg)?[\s,]+([\d.]+)%[\s,]+([\d.]+)%\s*(?:[/,]\s*([\d.]+%?))?\s*\)$/);
+	if (!match) return null;
+	const [, hue, saturation, lightness, alpha] = match;
+	if (!hue || !saturation || !lightness) return null;
+	return hslaToHsva({
+		h: Number.parseFloat(hue),
+		s: Number.parseFloat(saturation),
+		l: Number.parseFloat(lightness),
+		a: readAlpha(alpha)
+	});
+}
+function parseOklchFunction(raw) {
+	const match = raw.match(/^oklch\(\s*([\d.]+%?)\s+([\d.]+%?)\s+([\d.]+)\s*(?:[/,]\s*([\d.]+%?))?\s*\)$/);
+	if (!match) return null;
+	const [, lightness, chroma, hue, alpha] = match;
+	if (!lightness || !chroma || !hue) return null;
+	return oklchaToHsva({
+		L: lightness.endsWith("%") ? Number.parseFloat(lightness) / 100 : Number.parseFloat(lightness),
+		C: chroma.endsWith("%") ? Number.parseFloat(chroma) / 100 * .4 : Number.parseFloat(chroma),
+		H: Number.parseFloat(hue),
+		a: readAlpha(alpha)
+	});
+}
+function parseColor(input) {
+	const raw = input.trim().toLowerCase();
+	if (!raw) return null;
+	const named = NAMED[raw];
+	if (named) return parseHexColor(named);
+	if (raw.startsWith("#")) return parseHexColor(raw);
+	return parseRgbFunction(raw) ?? parseHslFunction(raw) ?? parseOklchFunction(raw);
+}
+function preserveAchromatic(next, prev) {
+	const out = { ...next };
+	if (out.v === 0) {
+		out.h = prev.h;
+		out.s = prev.s;
+	} else if (out.s === 0) out.h = prev.h;
+	return out;
+}
+function getChannels(hsva, format) {
+	const alpha = {
+		id: "a",
+		label: "A",
+		value: round(clamp01(hsva.a) * 100),
+		min: 0,
+		max: 100,
+		step: 1
+	};
+	switch (format) {
+		case "hex":
+		case "rgb": {
+			const { r, g, b } = hsvaToRgba(hsva);
+			return [
+				{
+					id: "r",
+					label: "R",
+					value: round(r),
+					min: 0,
+					max: 255,
+					step: 1
+				},
+				{
+					id: "g",
+					label: "G",
+					value: round(g),
+					min: 0,
+					max: 255,
+					step: 1
+				},
+				{
+					id: "b",
+					label: "B",
+					value: round(b),
+					min: 0,
+					max: 255,
+					step: 1
+				},
+				alpha
+			];
+		}
+		case "hsl": {
+			const { h, s, l } = hsvaToHsla(hsva);
+			return [
+				{
+					id: "h",
+					label: "H",
+					value: round(wrapHue(h)),
+					min: 0,
+					max: 360,
+					step: 1
+				},
+				{
+					id: "s",
+					label: "S",
+					value: round(s),
+					min: 0,
+					max: 100,
+					step: 1
+				},
+				{
+					id: "l",
+					label: "L",
+					value: round(l),
+					min: 0,
+					max: 100,
+					step: 1
+				},
+				alpha
+			];
+		}
+		case "oklch": {
+			const { L, C, H } = hsvaToOklcha(hsva);
+			return [
+				{
+					id: "okl",
+					label: "L",
+					value: Number(trimNum(L, 3)),
+					min: 0,
+					max: 1,
+					step: .001
+				},
+				{
+					id: "okc",
+					label: "C",
+					value: Number(trimNum(C, 3)),
+					min: 0,
+					max: .4,
+					step: .001
+				},
+				{
+					id: "okh",
+					label: "H",
+					value: round(wrapHue(H)),
+					min: 0,
+					max: 360,
+					step: 1
+				},
+				alpha
+			];
+		}
+	}
+}
+function setChannel(hsva, id, value) {
+	switch (id) {
+		case "a": return {
+			...hsva,
+			a: clamp01(value / 100)
+		};
+		case "r":
+		case "g":
+		case "b": return preserveAchromatic({
+			...rgbaToHsva({
+				...hsvaToRgba(hsva),
+				[id]: clamp(value, 0, 255)
+			}),
+			a: hsva.a
+		}, hsva);
+		case "h": return {
+			...hsva,
+			...hslaToHsva({
+				...hsvaToHsla(hsva),
+				h: wrapHue(value)
+			}),
+			a: hsva.a
+		};
+		case "s":
+		case "l": {
+			const hsla = hsvaToHsla(hsva);
+			const key = id === "s" ? "s" : "l";
+			return preserveAchromatic({
+				...hslaToHsva({
+					...hsla,
+					[key]: clamp(value, 0, 100)
+				}),
+				h: hsla.h,
+				a: hsva.a
+			}, hsva);
+		}
+		case "okl":
+		case "okc":
+		case "okh": {
+			const ok = hsvaToOklcha(hsva);
+			let mapped = ok;
+			if (id === "okl") mapped = {
+				...ok,
+				L: clamp01(value)
+			};
+			else if (id === "okc") mapped = {
+				...ok,
+				C: clamp(value, 0, .5)
+			};
+			else mapped = {
+				...ok,
+				H: wrapHue(value)
+			};
+			return preserveAchromatic({
+				...oklchaToHsva(mapped),
+				a: hsva.a
+			}, hsva);
+		}
+	}
+}
+function pointToSaturationValue(rect, offsetX, offsetY) {
+	return {
+		s: rect.width <= 0 ? 0 : clamp01(offsetX / rect.width) * 100,
+		v: rect.height <= 0 ? 0 : (1 - clamp01(offsetY / rect.height)) * 100
+	};
+}
+function formatGradient(stops, type, angle) {
+	const list = [...stops].sort((a, b) => a.position - b.position).map((stop) => `${stop.color} ${round(clamp01(stop.position) * 100)}%`).join(", ");
+	switch (type) {
+		case "linear": return `linear-gradient(${round(angle)}deg, ${list})`;
+		case "radial": return `radial-gradient(circle, ${list})`;
+		case "conic": return `conic-gradient(from ${round(angle)}deg, ${list})`;
+	}
+}
+function pointToHueSat(rect, offsetX, offsetY) {
+	const cx = rect.width / 2;
+	const cy = rect.height / 2;
+	const dx = offsetX - cx;
+	const dy = offsetY - cy;
+	const radius = Math.min(cx, cy);
+	const dist = Math.hypot(dx, dy);
+	let h = Math.atan2(dy, dx) * 180 / Math.PI;
+	h = wrapHue(h);
+	const s = radius <= 0 ? 0 : clamp01(dist / radius) * 100;
+	return {
+		h,
+		s
+	};
+}
+//#endregion
+export { formatColor, formatGradient, getChannels, hexToRgba, hslaToHsva, hslaToRgba, hsvaToHsla, hsvaToOklcha, hsvaToRgba, oklchaToHsva, parseColor, pointToHueSat, pointToSaturationValue, rgbaToHex, rgbaToHsla, rgbaToHsva, setChannel };

package/dist/lib/contrast.d.ts

@@ -0,0 +1,30 @@
+import { Hsva, Rgba } from "./color.js";
+//#region src/lib/contrast.d.ts
+type WcagLevel = "AA" | "AAA";
+type WcagLevels = {
+  AA: boolean;
+  AAA: boolean;
+};
+declare const AA_RATIO = 4.5;
+declare const AAA_RATIO = 7;
+declare const TARGET_RATIO: Record<WcagLevel, number>;
+declare function luminanceFromRgb({ r, g, b }: {
+  r: number;
+  g: number;
+  b: number;
+}): number;
+declare function contrastRatio(a: {
+  r: number;
+  g: number;
+  b: number;
+}, b: {
+  r: number;
+  g: number;
+  b: number;
+}): number;
+declare function wcagLevels(ratio: number): WcagLevels;
+declare function nextFixLevel(levels: WcagLevels): WcagLevel | null;
+declare function contrastOf(color: Hsva, background: Rgba): number;
+declare function fixColorForContrast(color: Hsva, background: Rgba, target?: number): Hsva | null;
+//#endregion
+export { AAA_RATIO, AA_RATIO, TARGET_RATIO, WcagLevel, WcagLevels, contrastOf, contrastRatio, fixColorForContrast, luminanceFromRgb, nextFixLevel, wcagLevels };

package/dist/lib/contrast.js

@@ -0,0 +1,64 @@
+import { hsvaToOklcha, hsvaToRgba, oklchaToHsva } from "./color.js";
+//#region src/lib/contrast.ts
+const AA_RATIO = 4.5;
+const AAA_RATIO = 7;
+const TARGET_RATIO = {
+	AA: AA_RATIO,
+	AAA: 7
+};
+function channelLuminance(c) {
+	const s = c / 255;
+	return s <= .03928 ? s / 12.92 : ((s + .055) / 1.055) ** 2.4;
+}
+function luminanceFromRgb({ r, g, b }) {
+	return .2126 * channelLuminance(r) + .7152 * channelLuminance(g) + .0722 * channelLuminance(b);
+}
+function contrastRatio(a, b) {
+	const la = luminanceFromRgb(a) + .05;
+	const lb = luminanceFromRgb(b) + .05;
+	return la > lb ? la / lb : lb / la;
+}
+function wcagLevels(ratio) {
+	return {
+		AA: ratio >= AA_RATIO,
+		AAA: ratio >= 7
+	};
+}
+function nextFixLevel(levels) {
+	if (!levels.AA) return "AA";
+	if (!levels.AAA) return "AAA";
+	return null;
+}
+function contrastOf(color, background) {
+	return contrastRatio(hsvaToRgba(color), background);
+}
+function fixColorForContrast(color, background, target = AA_RATIO) {
+	const ok = hsvaToOklcha(color);
+	const ratioAtL = (L) => contrastRatio(hsvaToRgba(oklchaToHsva({
+		L,
+		C: ok.C,
+		H: ok.H,
+		a: 1
+	})), background);
+	if (ratioAtL(ok.L) >= target) return null;
+	let best = null;
+	for (let step = 0; step <= 100; step++) {
+		const L = step / 100;
+		if (ratioAtL(L) < target) continue;
+		const dist = Math.abs(L - ok.L);
+		if (!best || dist < best.dist) best = {
+			L,
+			dist
+		};
+	}
+	const pick = (L) => oklchaToHsva({
+		L,
+		C: ok.C,
+		H: ok.H,
+		a: color.a
+	});
+	if (best) return pick(best.L);
+	return ratioAtL(0) >= ratioAtL(1) ? pick(0) : pick(1);
+}
+//#endregion
+export { AAA_RATIO, AA_RATIO, TARGET_RATIO, contrastOf, contrastRatio, fixColorForContrast, luminanceFromRgb, nextFixLevel, wcagLevels };

package/dist/lib/diff.d.ts

@@ -0,0 +1,50 @@
+//#region src/lib/diff.d.ts
+type CodeDiffLineType = "add" | "del" | "context";
+type CodeLineType = CodeDiffLineType;
+type LineDiffType = "word" | "char" | "none";
+type DiffFileType = "change" | "new" | "deleted" | "rename";
+type DiffSegment = {
+  text: string;
+  emphasis: boolean;
+};
+type DiffLine = {
+  type: CodeLineType;
+  oldNo?: number;
+  newNo?: number;
+  text: string;
+  segments?: DiffSegment[];
+};
+type DiffHunk = {
+  header?: string;
+  oldStart: number;
+  oldCount: number;
+  newStart: number;
+  newCount: number;
+  lines: DiffLine[];
+  collapsedBefore: number;
+};
+type DiffFile = {
+  name: string;
+  oldName?: string;
+  type: DiffFileType;
+  lang?: string;
+  hunks: DiffHunk[];
+  oldLines: string[];
+  newLines: string[];
+  isPartial: boolean;
+  additions: number;
+  deletions: number;
+};
+type BuildDiffOptions = {
+  name?: string;
+  lang?: string;
+  context?: number;
+  lineDiffType?: LineDiffType;
+  maxLineDiffLength?: number;
+};
+declare function computeWordDiff(oldText: string, newText: string, kind: LineDiffType, maxLength: number): [DiffSegment[] | undefined, DiffSegment[] | undefined];
+declare function diffRunEnd(lines: readonly DiffLine[], start: number, type: DiffLine["type"]): number;
+declare function buildDiffFromFiles(oldText: string, newText: string, options?: BuildDiffOptions): DiffFile;
+declare function buildDiffFromPatch(patchText: string, options?: BuildDiffOptions): DiffFile[];
+//#endregion
+export { BuildDiffOptions, CodeDiffLineType, CodeLineType, DiffFile, DiffFileType, DiffHunk, DiffLine, DiffSegment, LineDiffType, buildDiffFromFiles, buildDiffFromPatch, computeWordDiff, diffRunEnd };