@visual-z/xeno 0.1.4 → 0.2.1

package/src/vendor/pi-tui/colors.ts

@@ -0,0 +1,367 @@
+import { linearSrgbToRgb, okhslToRgb, oklabToLinearSrgb, rgbToOkhsl, rgbToOklab } from "./oklab.ts";
+import type { RgbColor } from "./terminal-colors.ts";
+
+export interface IndexedColor {
+	readonly kind: "indexed";
+	readonly index: number;
+}
+
+export interface RgbColorValue {
+	readonly kind: "rgb";
+	readonly r: number;
+	readonly g: number;
+	readonly b: number;
+}
+
+export interface OklchColorValue {
+	readonly kind: "oklch";
+	readonly l: number;
+	readonly c: number;
+	readonly h: number;
+}
+
+/** A concrete color. Every color can be converted to sRGB, so color math never fails. */
+export type Color = IndexedColor | RgbColorValue | OklchColorValue;
+export type TerminalColorMode = "256color" | "truecolor";
+export type ColorMixSpace = "oklch" | "srgb";
+
+export interface OklchChannels {
+	l: number;
+	c: number;
+	h: number;
+}
+
+/**
+ * OKHSL channels: hue in degrees, saturation and lightness 0-1. Saturation is relative to the most the
+ * sRGB gamut allows at that hue and lightness, so every value is in gamut.
+ */
+export interface OkhslChannels {
+	h: number;
+	s: number;
+	l: number;
+}
+
+export interface TextAttributes {
+	bold?: boolean;
+	dim?: boolean;
+	italic?: boolean;
+	underline?: boolean;
+	inverse?: boolean;
+	strikethrough?: boolean;
+}
+
+export interface TextStyle extends TextAttributes {
+	fg?: Color;
+	bg?: Color;
+}
+
+function requireFinite(value: number, name: string): void {
+	if (!Number.isFinite(value)) throw new Error(`${name} must be finite`);
+}
+
+export function indexedColor(index: number): IndexedColor {
+	if (!Number.isInteger(index) || index < 0 || index > 255) {
+		throw new Error(`ANSI color index must be an integer from 0 to 255: ${index}`);
+	}
+	return Object.freeze({ kind: "indexed", index });
+}
+
+export function rgbColor(r: number, g: number, b: number): RgbColorValue {
+	for (const [name, value] of [
+		["r", r],
+		["g", g],
+		["b", b],
+	] as const) {
+		requireFinite(value, name);
+		if (value < 0 || value > 255) throw new Error(`${name} must be between 0 and 255: ${value}`);
+	}
+	return Object.freeze({ kind: "rgb", r, g, b });
+}
+
+export function oklchColor(l: number, c: number, h: number): OklchColorValue {
+	requireFinite(l, "l");
+	requireFinite(c, "c");
+	requireFinite(h, "h");
+	if (l < 0 || l > 1) throw new Error(`l must be between 0 and 1: ${l}`);
+	if (c < 0) throw new Error(`c must not be negative: ${c}`);
+	return Object.freeze({ kind: "oklch", l, c, h: ((h % 360) + 360) % 360 });
+}
+
+const NUMBER_PATTERN = String.raw`[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?`;
+const OKLCH_PATTERN = new RegExp(
+	`^oklch\\(\\s*(${NUMBER_PATTERN})(%)?\\s+(${NUMBER_PATTERN})\\s+(${NUMBER_PATTERN})(?:deg)?\\s*\\)$`,
+	"i",
+);
+const OKHSL_PATTERN = new RegExp(
+	`^okhsl\\(\\s*(${NUMBER_PATTERN})(?:deg)?\\s+(${NUMBER_PATTERN})(%)?\\s+(${NUMBER_PATTERN})(%)?\\s*\\)$`,
+	"i",
+);
+
+/**
+ * An OKHSL color, converted to sRGB. Saturation is relative to the sRGB gamut at the hue and lightness,
+ * so equal saturation looks equally colorful across hues and lightness.
+ * @param h Hue in degrees.
+ * @param s Saturation, 0-1.
+ * @param l Lightness, 0-1.
+ */
+export function okhslColor(h: number, s: number, l: number): RgbColorValue {
+	requireFinite(h, "h");
+	requireFinite(s, "s");
+	requireFinite(l, "l");
+	if (s < 0 || s > 1) throw new Error(`s must be between 0 and 1: ${s}`);
+	if (l < 0 || l > 1) throw new Error(`l must be between 0 and 1: ${l}`);
+	const { r, g, b } = okhslToRgb(h, s, l);
+	return rgbColor(r, g, b);
+}
+
+export function colorToOkhsl(color: Color): OkhslChannels {
+	return rgbToOkhsl(colorToRgb(color));
+}
+
+export function parseColor(value: string | number): Color {
+	if (typeof value === "number") return indexedColor(value);
+
+	const hex = /^#([\da-f]{3}|[\da-f]{6})$/i.exec(value);
+	if (hex) {
+		const digits = hex[1].length === 3 ? [...hex[1]].map((digit) => digit + digit).join("") : hex[1];
+		return rgbColor(
+			Number.parseInt(digits.slice(0, 2), 16),
+			Number.parseInt(digits.slice(2, 4), 16),
+			Number.parseInt(digits.slice(4, 6), 16),
+		);
+	}
+
+	const oklch = OKLCH_PATTERN.exec(value);
+	if (oklch) {
+		const lightness = Number.parseFloat(oklch[1]) / (oklch[2] ? 100 : 1);
+		return oklchColor(lightness, Number.parseFloat(oklch[3]), Number.parseFloat(oklch[4]));
+	}
+
+	const okhsl = OKHSL_PATTERN.exec(value);
+	if (okhsl) {
+		const saturation = Number.parseFloat(okhsl[2]) / (okhsl[3] ? 100 : 1);
+		const lightness = Number.parseFloat(okhsl[4]) / (okhsl[5] ? 100 : 1);
+		return okhslColor(Number.parseFloat(okhsl[1]), saturation, lightness);
+	}
+
+	throw new Error(`Invalid color value: ${value}`);
+}
+
+const BASIC_COLORS: readonly RgbColor[] = [
+	{ r: 0, g: 0, b: 0 },
+	{ r: 128, g: 0, b: 0 },
+	{ r: 0, g: 128, b: 0 },
+	{ r: 128, g: 128, b: 0 },
+	{ r: 0, g: 0, b: 128 },
+	{ r: 128, g: 0, b: 128 },
+	{ r: 0, g: 128, b: 128 },
+	{ r: 192, g: 192, b: 192 },
+	{ r: 128, g: 128, b: 128 },
+	{ r: 255, g: 0, b: 0 },
+	{ r: 0, g: 255, b: 0 },
+	{ r: 255, g: 255, b: 0 },
+	{ r: 0, g: 0, b: 255 },
+	{ r: 255, g: 0, b: 255 },
+	{ r: 0, g: 255, b: 255 },
+	{ r: 255, g: 255, b: 255 },
+];
+const CUBE_VALUES = [0, 95, 135, 175, 215, 255] as const;
+const GRAY_VALUES = Array.from({ length: 24 }, (_, index) => 8 + index * 10);
+
+function indexedToRgb(index: number): RgbColor {
+	if (index < 16) return { ...BASIC_COLORS[index] };
+	if (index < 232) {
+		const cubeIndex = index - 16;
+		return {
+			r: CUBE_VALUES[Math.floor(cubeIndex / 36)],
+			g: CUBE_VALUES[Math.floor((cubeIndex % 36) / 6)],
+			b: CUBE_VALUES[cubeIndex % 6],
+		};
+	}
+	const gray = 8 + (index - 232) * 10;
+	return { r: gray, g: gray, b: gray };
+}
+
+function isInSrgbGamut(linear: number[]): boolean {
+	const epsilon = 1e-7;
+	return linear.every((channel) => channel >= -epsilon && channel <= 1 + epsilon);
+}
+
+function oklchToRgb({ l, c, h }: OklchChannels): RgbColor {
+	// Gamut mapping keeps the hue fixed, so its direction is computed once and scaled by chroma.
+	const radians = (h * Math.PI) / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	const atChroma = (chroma: number) => oklabToLinearSrgb([l, chroma * cos, chroma * sin]);
+
+	const direct = atChroma(c);
+	if (isInSrgbGamut(direct)) return linearSrgbToRgb(direct);
+
+	// Reduce chroma until the color fits. The achromatic color is always in gamut, so it is the
+	// fallback when no bisection step fits, e.g. `oklch(100% 0.3 150)` must map to white.
+	let linear = atChroma(0);
+	let low = 0;
+	let high = c;
+	for (let index = 0; index < 20; index++) {
+		const chroma = (low + high) / 2;
+		const candidate = atChroma(chroma);
+		if (isInSrgbGamut(candidate)) {
+			low = chroma;
+			linear = candidate;
+		} else {
+			high = chroma;
+		}
+	}
+	return linearSrgbToRgb(linear);
+}
+
+export function colorToRgb(color: Color): RgbColor {
+	switch (color.kind) {
+		case "indexed":
+			return indexedToRgb(color.index);
+		case "rgb":
+			return { r: color.r, g: color.g, b: color.b };
+		case "oklch":
+			return oklchToRgb(color);
+	}
+}
+
+export function colorToOklch(color: Color): OklchChannels {
+	if (color.kind === "oklch") return { l: color.l, c: color.c, h: color.h };
+	const [l, a, b] = rgbToOklab(colorToRgb(color));
+	return { l, c: Math.hypot(a, b), h: ((Math.atan2(b, a) * 180) / Math.PI + 360) % 360 };
+}
+
+export function colorToHex(color: Color): string {
+	const { r, g, b } = colorToRgb(color);
+	const channel = (value: number) => Math.round(value).toString(16).padStart(2, "0");
+	return `#${channel(r)}${channel(g)}${channel(b)}`;
+}
+
+export function mixColors(first: Color, second: Color, amount: number, space: ColorMixSpace = "oklch"): Color {
+	requireFinite(amount, "amount");
+	if (amount < 0 || amount > 1) throw new Error(`amount must be between 0 and 1: ${amount}`);
+
+	if (space === "srgb") {
+		const a = colorToRgb(first);
+		const b = colorToRgb(second);
+		return rgbColor(a.r + (b.r - a.r) * amount, a.g + (b.g - a.g) * amount, a.b + (b.b - a.b) * amount);
+	}
+
+	const a = colorToOklch(first);
+	const b = colorToOklch(second);
+	const firstHue = a.c < 1e-7 ? b.h : a.h;
+	const secondHue = b.c < 1e-7 ? firstHue : b.h;
+	const hueDelta = ((secondHue - firstHue + 540) % 360) - 180;
+	return oklchColor(a.l + (b.l - a.l) * amount, a.c + (b.c - a.c) * amount, firstHue + hueDelta * amount);
+}
+
+function findClosest(values: readonly number[], target: number): number {
+	let closestIndex = 0;
+	let closestDistance = Infinity;
+	for (let index = 0; index < values.length; index++) {
+		const distance = Math.abs(target - values[index]);
+		if (distance < closestDistance) {
+			closestIndex = index;
+			closestDistance = distance;
+		}
+	}
+	return closestIndex;
+}
+
+function colorDistance(first: RgbColor, second: RgbColor): number {
+	const dr = first.r - second.r;
+	const dg = first.g - second.g;
+	const db = first.b - second.b;
+	return dr * dr * 0.299 + dg * dg * 0.587 + db * db * 0.114;
+}
+
+function rgbToAnsi256(color: RgbColor): number {
+	const rIndex = findClosest(CUBE_VALUES, color.r);
+	const gIndex = findClosest(CUBE_VALUES, color.g);
+	const bIndex = findClosest(CUBE_VALUES, color.b);
+	const cubeColor = { r: CUBE_VALUES[rIndex], g: CUBE_VALUES[gIndex], b: CUBE_VALUES[bIndex] };
+	const cubeIndex = 16 + 36 * rIndex + 6 * gIndex + bIndex;
+
+	const gray = Math.round(0.299 * color.r + 0.587 * color.g + 0.114 * color.b);
+	const grayOffset = findClosest(GRAY_VALUES, gray);
+	const grayValue = GRAY_VALUES[grayOffset];
+	const spread = Math.max(color.r, color.g, color.b) - Math.min(color.r, color.g, color.b);
+	if (
+		spread < 10 &&
+		colorDistance(color, { r: grayValue, g: grayValue, b: grayValue }) < colorDistance(color, cubeColor)
+	) {
+		return 232 + grayOffset;
+	}
+	return cubeIndex;
+}
+
+function colorAnsi(color: Color, mode: TerminalColorMode, background: boolean): string {
+	if (color.kind === "indexed") return `\x1b[${background ? 48 : 38};5;${color.index}m`;
+
+	const rgb = colorToRgb(color);
+	if (mode === "truecolor") {
+		return `\x1b[${background ? 48 : 38};2;${Math.round(rgb.r)};${Math.round(rgb.g)};${Math.round(rgb.b)}m`;
+	}
+	return `\x1b[${background ? 48 : 38};5;${rgbToAnsi256(rgb)}m`;
+}
+
+export function foregroundAnsi(color: Color, mode: TerminalColorMode): string {
+	return colorAnsi(color, mode, false);
+}
+
+export function backgroundAnsi(color: Color, mode: TerminalColorMode): string {
+	return colorAnsi(color, mode, true);
+}
+
+export function styleText(text: string, options: TextStyle, mode: TerminalColorMode): string {
+	return styleTextWithAnsi(
+		text,
+		options.fg && foregroundAnsi(options.fg, mode),
+		options.bg && backgroundAnsi(options.bg, mode),
+		options,
+	);
+}
+
+/**
+ * Like `styleText()`, but with precomputed color escape sequences, e.g. cached theme colors.
+ * Colors in `options` are ignored.
+ */
+export function styleTextWithAnsi(
+	text: string,
+	fgAnsi: string | undefined,
+	bgAnsi: string | undefined,
+	options: TextAttributes,
+): string {
+	// Resets are prepended so they close in reverse order of the opening sequences.
+	let prefix = "";
+	let suffix = "";
+	if (fgAnsi) {
+		prefix += fgAnsi;
+		suffix = "\x1b[39m";
+	}
+	if (bgAnsi) {
+		prefix += bgAnsi;
+		suffix = `\x1b[49m${suffix}`;
+	}
+	if (options.bold) prefix += "\x1b[1m";
+	if (options.dim) prefix += "\x1b[2m";
+	if (options.bold || options.dim) suffix = `\x1b[22m${suffix}`;
+	if (options.italic) {
+		prefix += "\x1b[3m";
+		suffix = `\x1b[23m${suffix}`;
+	}
+	if (options.underline) {
+		prefix += "\x1b[4m";
+		suffix = `\x1b[24m${suffix}`;
+	}
+	if (options.inverse) {
+		prefix += "\x1b[7m";
+		suffix = `\x1b[27m${suffix}`;
+	}
+	if (options.strikethrough) {
+		prefix += "\x1b[9m";
+		suffix = `\x1b[29m${suffix}`;
+	}
+	return `${prefix}${text}${suffix}`;
+}

package/src/vendor/pi-tui/components/box.ts

@@ -1,5 +1,5 @@
 import { type Component, dispatchMouseEvent, type TuiMouseDispatchResult, type TuiMouseEvent } from "../tui.ts";
-import { applyBackgroundToLine, visibleWidth } from "../utils.ts";
+import { visibleWidth } from "../utils.ts";
 
 type RenderCache = {
 	childLines: string[];
@@ -106,14 +106,16 @@ export class Box implements Component {
 		const contentWidth = Math.max(1, width - this.paddingX * 2);
 		const leftPad = " ".repeat(this.paddingX);
 
-		// Render all children
+		// Render all children. Keep the child lines unpadded: children usually return the same string
+		// objects every frame, so the cache check below is a cheap identity comparison per line.
+		// Padding here would create new strings that must be compared character by character.
 		const childLines: string[] = [];
 		const mouseChildren: Array<{ component: Component; height: number }> = [];
 		for (const child of this.children) {
 			const lines = child.render(contentWidth);
 			mouseChildren.push({ component: child, height: lines.length });
 			for (const line of lines) {
-				childLines.push(leftPad + line);
+				childLines.push(line);
 			}
 		}
 		this.mouseLayout = { width: contentWidth, children: mouseChildren };
@@ -140,7 +142,7 @@ export class Box implements Component {
 
 		// Content
 		for (const line of childLines) {
-			result.push(this.applyBg(line, width));
+			result.push(this.applyBg(leftPad + line, width));
 		}
 
 		// Bottom padding
@@ -158,10 +160,7 @@ export class Box implements Component {
 		const visLen = visibleWidth(line);
 		const padNeeded = Math.max(0, width - visLen);
 		const padded = line + " ".repeat(padNeeded);
-
-		if (this.bgFn) {
-			return applyBackgroundToLine(padded, width, this.bgFn);
-		}
-		return padded;
+		// Already padded to width, so apply the background directly instead of measuring the line again.
+		return this.bgFn ? this.bgFn(padded) : padded;
 	}
 }

package/src/vendor/pi-tui/components/editor.ts

@@ -253,6 +253,8 @@ const ATTACHMENT_AUTOCOMPLETE_DEBOUNCE_MS = 20;
 const DEFAULT_AUTOCOMPLETE_TRIGGER_CHARACTERS = ["@", "#"];
 // Unquoted completions end at whitespace or CJK punctuation; quoted paths may contain either.
 const unquotedAutocompleteSuffixRegex = new RegExp(`(?:(?!${autocompleteSeparatorRegex.source}).)*`, "u");
+// Trigger tokens may be wrapped in prose, e.g. "(@src/foo" or "`@src/foo".
+const autocompleteTokenStartSource = `${autocompleteBoundaryRegex.source}[([{<\`]*`;
 
 function escapeCharacterClass(value: string): string {
 	return value.replace(/[\\^$.*+?()[\]{}|-]/g, "\\$&");
@@ -260,7 +262,7 @@ function escapeCharacterClass(value: string): string {
 
 function buildTriggerPattern(triggerCharacters: string[]): RegExp {
 	return new RegExp(
-		`${autocompleteBoundaryRegex.source}(?:@"[^"]*|[${triggerCharacters.map(escapeCharacterClass).join("")}]${unquotedAutocompleteSuffixRegex.source})$`,
+		`${autocompleteTokenStartSource}(?:@"[^"]*|[${triggerCharacters.map(escapeCharacterClass).join("")}]${unquotedAutocompleteSuffixRegex.source})$`,
 		"u",
 	);
 }
@@ -268,7 +270,7 @@ function buildTriggerPattern(triggerCharacters: string[]): RegExp {
 function buildDebouncePattern(triggerCharacters: string[]): RegExp {
 	const escapedWithoutAt = triggerCharacters.filter((character) => character !== "@").map(escapeCharacterClass);
 	return new RegExp(
-		`${autocompleteBoundaryRegex.source}(?:@(?:"[^"]*|${unquotedAutocompleteSuffixRegex.source})|[${escapedWithoutAt.join("")}]${unquotedAutocompleteSuffixRegex.source})$`,
+		`${autocompleteTokenStartSource}(?:@(?:"[^"]*|${unquotedAutocompleteSuffixRegex.source})|[${escapedWithoutAt.join("")}]${unquotedAutocompleteSuffixRegex.source})$`,
 		"u",
 	);
 }

package/src/vendor/pi-tui/components/markdown.ts

@@ -246,6 +246,8 @@ export class Markdown implements Component {
 	private cachedText?: string;
 	private cachedWidth?: number;
 	private cachedLines?: string[];
+	// Parsed tokens depend only on the source, so they survive theme and width invalidation.
+	private cachedTokens?: { source: string; tokens: Token[] };
 
 	constructor(
 		text: string,
@@ -298,8 +300,12 @@ export class Markdown implements Component {
 		const normalizedText = text.replace(/\t/g, "   ");
 
 		// Parse markdown to HTML-like tokens
-		const tokens = markdownParser.lexer(normalizedText);
-		trimPartialClosingFences(tokens);
+		let tokens = this.cachedTokens?.source === normalizedText ? this.cachedTokens.tokens : undefined;
+		if (!tokens) {
+			tokens = markdownParser.lexer(normalizedText);
+			trimPartialClosingFences(tokens);
+			this.cachedTokens = { source: normalizedText, tokens };
+		}
 
 		// Convert tokens to styled terminal output
 		const renderedLines: string[] = [];

package/src/vendor/pi-tui/index.ts

@@ -9,6 +9,33 @@ export {
 	CombinedAutocompleteProvider,
 	type SlashCommand,
 } from "./autocomplete.ts";
+// Colors and styling
+export {
+	backgroundAnsi,
+	type Color,
+	type ColorMixSpace,
+	colorToHex,
+	colorToOkhsl,
+	colorToOklch,
+	colorToRgb,
+	foregroundAnsi,
+	type IndexedColor,
+	indexedColor,
+	mixColors,
+	type OkhslChannels,
+	type OklchChannels,
+	type OklchColorValue,
+	okhslColor,
+	oklchColor,
+	parseColor,
+	type RgbColorValue,
+	rgbColor,
+	styleText,
+	styleTextWithAnsi,
+	type TerminalColorMode,
+	type TextAttributes,
+	type TextStyle,
+} from "./colors.ts";
 // Components
 export { Box } from "./components/box.ts";
 export { CancellableLoader } from "./components/cancellable-loader.ts";
@@ -77,16 +104,17 @@ export {
 export { type RenderLatexOptions, renderLatex } from "./latex.ts";
 // Native platform integration
 export { getNativeClipboard, type NativeClipboard } from "./native-platform.ts";
+export { oklabToOkhslLightness } from "./oklab.ts";
 // Input buffering for batch splitting
 export { StdinBuffer, type StdinBufferEventMap, type StdinBufferOptions } from "./stdin-buffer.ts";
 // Terminal interface and implementations
 export { ProcessTerminal, type Terminal } from "./terminal.ts";
 // Terminal colors
 export {
-	parseOsc11BackgroundColor,
 	parseTerminalColorSchemeReport,
 	type RgbColor,
 	type TerminalColorScheme,
+	type TerminalColors,
 } from "./terminal-colors.ts";
 // Terminal image support
 export {
@@ -104,6 +132,7 @@ export {
 	getImageDimensions,
 	getJpegDimensions,
 	getPngDimensions,
+	getTerminalColorMode,
 	getWebpDimensions,
 	hyperlink,
 	type ImageDimensions,
@@ -154,3 +183,4 @@ export {
 	visibleWidth,
 	wrapTextWithAnsi,
 } from "./utils.ts";
+export type { WheelScrollLines } from "./wheel-scroll.ts";

package/src/vendor/pi-tui/native/UPSTREAM.json

@@ -0,0 +1,23 @@
+{
+  "commit": "02eed88fd8912e54a804ddebd409e2e4c08ac5ef",
+  "files": {
+    "clipboard.h": "4e7d0a70f8e530017307816f097d355b94227c4d",
+    "darwin/README.md": "74c5c5911b480e3cffa23b18ec39a00a68fb71bd",
+    "darwin/build.sh": "65f7fa4f8cdc19be744b9519e95687bbb046df0e",
+    "darwin/prebuilds/darwin-arm64/darwin-platform.node": "3294b6bffd36eaab70d61134e9955992f31f9a8f",
+    "darwin/prebuilds/darwin-x64/darwin-platform.node": "014383575508654d9f898ee25631b88db8d9740c",
+    "darwin/src/darwin-platform.m": "5cdd8f9122309f2e4ed0aa107fe1f556b9f8934d",
+    "linux/README.md": "5efdb5cb69af75d5b596423a11a8411138a43ccd",
+    "linux/build.sh": "121b6c45d56020fb2bb78aa6f1a5627f0c094986",
+    "linux/prebuilds/linux-arm64/linux-platform-x11.node": "6d3abc4e33fe4fc8f9029cda1201a3a2aee5c050",
+    "linux/prebuilds/linux-x64/linux-platform-x11.node": "54fcd629b88533ee6c788a830038aa46cf78c1d7",
+    "linux/src/clipboard-worker.h": "93c79d0e7112096b86f38d6fdb1e21c0a72293d4",
+    "linux/src/linux-platform-x11.c": "578a850e43de0c4a00cff4f46c8d1cd31dc74a5f",
+    "napi.h": "816a8202e2fd4d69d3d1f834fbe353b7ef71744a",
+    "win32/README.md": "f3b58607cbaa893d1cdff1b0321ed39e793677ea",
+    "win32/build.mjs": "df1ed206131af71e22d042f5924649e7d742c09b",
+    "win32/prebuilds/win32-arm64/win32-platform.node": "ec330840e70b863b2b0f295437b78378fb8ac84b",
+    "win32/prebuilds/win32-x64/win32-platform.node": "2d0b749b53a17d6049f3e1629c73a847d3851d04",
+    "win32/src/win32-platform.c": "a637dda892b695a525ca2cb6b22ee9a8a55cae59"
+  }
+}