@singapore-editor/minimap 0.1.1

package/dist/assets/minimap.worker-i4S59IOV.js

@@ -0,0 +1,1616 @@
+//#region ../editor/dist/logging/evlog.js
+var evlogErrorInternalKey = Symbol.for("editor.evlog.error.internal");
+var EditorEvlogError = class extends Error {
+	[evlogErrorInternalKey];
+	code;
+	fix;
+	link;
+	status;
+	why;
+	constructor(options) {
+		const resolved = typeof options === "string" ? { message: options } : options;
+		super(resolved.message, { cause: resolved.cause });
+		this.name = "EvlogError";
+		this.code = resolved.code;
+		this.fix = resolved.fix;
+		this.link = resolved.link;
+		this.status = resolved.status ?? 500;
+		this.why = resolved.why;
+		if (resolved.internal !== void 0) this.defineInternal(resolved.internal);
+	}
+	get internal() {
+		return this[evlogErrorInternalKey];
+	}
+	get statusText() {
+		return this.message;
+	}
+	get statusCode() {
+		return this.status;
+	}
+	get statusMessage() {
+		return this.message;
+	}
+	get data() {
+		if (!this.code && !this.why && !this.fix && !this.link) return void 0;
+		return {
+			code: this.code,
+			why: this.why,
+			fix: this.fix,
+			link: this.link
+		};
+	}
+	toString() {
+		return evlogErrorLines(this).join("\n");
+	}
+	toJSON() {
+		const serialized = {
+			message: this.message,
+			name: this.name,
+			status: this.status
+		};
+		if (this.data) serialized.data = this.data;
+		if (this.cause instanceof Error) serialized.cause = {
+			message: this.cause.message,
+			name: this.cause.name
+		};
+		return serialized;
+	}
+	defineInternal(internal) {
+		Object.defineProperty(this, evlogErrorInternalKey, {
+			configurable: true,
+			enumerable: false,
+			value: internal,
+			writable: false
+		});
+	}
+};
+function createError(options) {
+	return new EditorEvlogError(options);
+}
+function evlogErrorLines(error) {
+	const lines = [`Error: ${error.message}`];
+	if (error.code) lines.push(`Code: ${error.code}`);
+	if (error.why) lines.push(`Why: ${error.why}`);
+	if (error.fix) lines.push(`Fix: ${error.fix}`);
+	if (error.link) lines.push(`More info: ${error.link}`);
+	if (error.cause instanceof Error) lines.push(`Caused by: ${error.cause.message}`);
+	return lines;
+}
+//#endregion
+//#region src/color.ts
+const RGBA_EMPTY = {
+	r: 0,
+	g: 0,
+	b: 0,
+	a: 0
+};
+function transparent(color, ratio) {
+	return {
+		...color,
+		a: clamp8(color.a * ratio)
+	};
+}
+function rgbaToCss(color) {
+	return `rgba(${color.r}, ${color.g}, ${color.b}, ${color.a / 255})`;
+}
+function parseCssColor(value, fallback = RGBA_EMPTY) {
+	if (!value) return fallback;
+	const trimmed = value.trim();
+	if (trimmed.startsWith("#")) return parseHexColor(trimmed, fallback);
+	if (trimmed.startsWith("rgb")) return parseRgbColor(trimmed, fallback);
+	return fallback;
+}
+function relativeLuminance(color) {
+	const r = linearRgb(color.r / 255);
+	const g = linearRgb(color.g / 255);
+	const b = linearRgb(color.b / 255);
+	return .2126 * r + .7152 * g + .0722 * b;
+}
+function clamp8(value) {
+	return Math.min(255, Math.max(0, Math.round(value)));
+}
+function parseHexColor(value, fallback) {
+	const hex = value.slice(1);
+	if (hex.length === 3) return shortHex(hex, fallback);
+	if (hex.length === 4) return shortHexAlpha(hex, fallback);
+	if (hex.length === 6) return longHex(hex, "ff", fallback);
+	if (hex.length === 8) return longHex(hex.slice(0, 6), hex.slice(6), fallback);
+	return fallback;
+}
+function shortHex(hex, fallback) {
+	return longHex(hex.split("").map((char) => char + char).join(""), "ff", fallback);
+}
+function shortHexAlpha(hex, fallback) {
+	const rgb = hex.slice(0, 3);
+	const alpha = hex[3] ?? "f";
+	return longHex(rgb.split("").map((char) => char + char).join(""), alpha + alpha, fallback);
+}
+function longHex(rgb, alpha, fallback) {
+	const value = Number.parseInt(rgb + alpha, 16);
+	if (!Number.isFinite(value)) return fallback;
+	return {
+		r: value >> 24 & 255,
+		g: value >> 16 & 255,
+		b: value >> 8 & 255,
+		a: value & 255
+	};
+}
+function parseRgbColor(value, fallback) {
+	const parts = value.slice(value.indexOf("(") + 1, value.lastIndexOf(")")).split(/[,\s/]+/).filter(Boolean);
+	if (parts.length < 3) return fallback;
+	return {
+		r: clamp8(Number(parts[0])),
+		g: clamp8(Number(parts[1])),
+		b: clamp8(Number(parts[2])),
+		a: alphaPart(parts[3])
+	};
+}
+function alphaPart(value) {
+	if (!value) return 255;
+	if (value.endsWith("%")) return clamp8(Number.parseFloat(value) / 100 * 255);
+	const number = Number(value);
+	if (!Number.isFinite(number)) return 255;
+	if (number <= 1) return clamp8(number * 255);
+	return clamp8(number);
+}
+function linearRgb(value) {
+	if (value <= .04045) return value / 12.92;
+	return ((value + .055) / 1.055) ** 2.4;
+}
+//#endregion
+//#region src/minimapCharSheet.ts
+let Constants = /* @__PURE__ */ function(Constants) {
+	Constants[Constants["START_CH_CODE"] = 32] = "START_CH_CODE";
+	Constants[Constants["END_CH_CODE"] = 126] = "END_CH_CODE";
+	Constants[Constants["UNKNOWN_CODE"] = 65533] = "UNKNOWN_CODE";
+	Constants[Constants["CHAR_COUNT"] = 96] = "CHAR_COUNT";
+	Constants[Constants["SAMPLED_CHAR_HEIGHT"] = 16] = "SAMPLED_CHAR_HEIGHT";
+	Constants[Constants["SAMPLED_CHAR_WIDTH"] = 10] = "SAMPLED_CHAR_WIDTH";
+	Constants[Constants["BASE_CHAR_HEIGHT"] = 2] = "BASE_CHAR_HEIGHT";
+	Constants[Constants["BASE_CHAR_WIDTH"] = 1] = "BASE_CHAR_WIDTH";
+	Constants[Constants["RGBA_CHANNELS_CNT"] = 4] = "RGBA_CHANNELS_CNT";
+	Constants[Constants["RGBA_SAMPLED_ROW_WIDTH"] = 3840] = "RGBA_SAMPLED_ROW_WIDTH";
+	return Constants;
+}({});
+const allCharCodes = (() => {
+	const values = [];
+	for (let index = 32; index <= 126; index += 1) values.push(index);
+	values.push(65533);
+	return values;
+})();
+const getCharIndex = (chCode, fontScale) => {
+	const index = chCode - 32;
+	if (index >= 0 && index <= 96) return index;
+	if (fontScale <= 2) return (index + 96) % 96;
+	return 95;
+};
+//#endregion
+//#region src/types.ts
+let RenderMinimap = /* @__PURE__ */ function(RenderMinimap) {
+	RenderMinimap[RenderMinimap["None"] = 0] = "None";
+	RenderMinimap[RenderMinimap["Text"] = 1] = "Text";
+	RenderMinimap[RenderMinimap["Blocks"] = 2] = "Blocks";
+	return RenderMinimap;
+}({});
+function computeRenderLayout(options) {
+	const pixelRatio = Math.max(1, options.metrics.devicePixelRatio);
+	const height = Math.max(0, options.viewport.minimapHeight);
+	const baseCharHeight = options.minimap.renderCharacters ? Constants.BASE_CHAR_HEIGHT : Constants.BASE_CHAR_HEIGHT + 1;
+	const configuredScale = pixelRatio >= 2 ? Math.round(options.minimap.scale * 2) : options.minimap.scale;
+	const baseCanvasInnerHeight = Math.floor(pixelRatio * height);
+	const fitted = computeFittedScale({
+		baseCharHeight,
+		canvasInnerHeight: baseCanvasInnerHeight,
+		configuredScale,
+		height,
+		lineCount: options.lineCount,
+		minimap: (options.viewport.visibleEnd - options.viewport.visibleStart) * baseCharHeight * configuredScale > baseCanvasInnerHeight ? {
+			...options.minimap,
+			size: "fill"
+		} : options.minimap,
+		pixelRatio,
+		rowHeight: options.metrics.rowHeight
+	});
+	const width = computeMinimapWidth({
+		charWidth: fitted.scale / pixelRatio / fitted.widthMultiplier,
+		maxColumn: options.minimap.maxColumn,
+		viewportWidth: options.viewport.clientWidth + Math.max(0, options.viewport.reservedWidth),
+		characterWidth: options.metrics.characterWidth
+	});
+	const baseCanvasInnerWidth = Math.floor(pixelRatio * width);
+	return {
+		width,
+		height,
+		canvasInnerWidth: Math.floor(baseCanvasInnerWidth * fitted.widthMultiplier),
+		canvasInnerHeight: fitted.heightIsEditorHeight ? Math.ceil(Math.max(baseCanvasInnerHeight, fitted.documentMinimapHeight)) : baseCanvasInnerHeight,
+		canvasOuterWidth: baseCanvasInnerWidth / pixelRatio,
+		canvasOuterHeight: baseCanvasInnerHeight / pixelRatio,
+		lineHeight: fitted.lineHeight,
+		charWidth: Constants.BASE_CHAR_WIDTH * fitted.scale,
+		scale: fitted.scale,
+		isSampling: fitted.isSampling,
+		heightIsEditorHeight: fitted.heightIsEditorHeight,
+		renderMinimap: options.minimap.enabled ? options.minimap.renderCharacters ? RenderMinimap.Text : RenderMinimap.Blocks : RenderMinimap.None
+	};
+}
+function computeFrameLayout(options) {
+	const { renderLayout: layout, viewport, realLineCount } = options;
+	const pixelRatio = layout.canvasInnerHeight / Math.max(1, layout.canvasOuterHeight);
+	const documentLineHeight = layout.isSampling ? layout.height / Math.max(1, realLineCount) : layout.lineHeight / pixelRatio;
+	const start = Math.min(realLineCount, Math.max(0, viewport.visibleStart));
+	const visibleCount = Math.min(realLineCount, Math.max(start, viewport.visibleEnd)) - start;
+	const linesFitting = layout.height / documentLineHeight;
+	const travel = Math.max(0, realLineCount - linesFitting);
+	const progress = start / Math.max(1, realLineCount - visibleCount);
+	const documentStart = Math.min(start, travel * progress);
+	const rasterStart = layout.isSampling ? 0 : documentStart;
+	const startLineNumber = Math.floor(rasterStart) + 1;
+	const startLineFraction = rasterStart - Math.floor(rasterStart);
+	return {
+		scrollTop: viewport.scrollTop,
+		scrollHeight: viewport.scrollHeight,
+		sliderNeeded: visibleCount < realLineCount,
+		documentLineHeight,
+		sliderLineHeight: travel > 0 ? Math.max(0, layout.height - visibleCount * documentLineHeight) / Math.max(1, realLineCount - visibleCount) : documentLineHeight,
+		documentStart,
+		sliderTop: (start - documentStart) * documentLineHeight,
+		sliderHeight: Math.min(layout.height, visibleCount * documentLineHeight),
+		topPaddingLineCount: 0,
+		startLineNumber,
+		startLineFraction,
+		endLineNumber: Math.min(options.lineCount, startLineNumber + Math.ceil(layout.canvasInnerHeight / layout.lineHeight + startLineFraction) - 1)
+	};
+}
+function yForLineNumber(frame, lineNumber, minimapLineHeight) {
+	return (lineNumber - frame.startLineNumber + frame.topPaddingLineCount) * minimapLineHeight;
+}
+function computeFittedScale(options) {
+	const lineHeight = options.baseCharHeight * options.configuredScale;
+	if (options.minimap.size === "proportional") return fittedScale(options.configuredScale, lineHeight, 1, false, false, 0);
+	const desiredRatio = options.lineCount / Math.max(1, options.canvasInnerHeight);
+	if (desiredRatio > 1) return fittedScale(1, 1, 1, true, true, options.canvasInnerHeight);
+	if (options.minimap.size === "fit") {
+		const documentHeight = Math.ceil(options.lineCount * lineHeight);
+		if (documentHeight <= options.canvasInnerHeight) return fittedScale(options.configuredScale, lineHeight, 1, false, false, documentHeight);
+	}
+	const maxScale = options.configuredScale + 1;
+	const fillLineHeight = Math.min(options.rowHeight * options.pixelRatio, Math.max(1, Math.floor(1 / desiredRatio)));
+	const scale = Math.min(maxScale, Math.max(1, Math.floor(fillLineHeight / options.baseCharHeight)));
+	const widthMultiplier = scale > options.configuredScale ? Math.min(2, scale / options.configuredScale) : 1;
+	const typicalViewportLineCount = options.height / Math.max(1, options.rowHeight);
+	return fittedScale(scale, fillLineHeight, widthMultiplier, false, true, Math.ceil(Math.max(typicalViewportLineCount, options.lineCount) * fillLineHeight));
+}
+function fittedScale(scale, lineHeight, widthMultiplier, isSampling, heightIsEditorHeight, documentMinimapHeight) {
+	return {
+		scale,
+		lineHeight,
+		widthMultiplier,
+		isSampling,
+		heightIsEditorHeight,
+		documentMinimapHeight
+	};
+}
+function computeMinimapWidth(options) {
+	const availableWidth = Math.max(0, options.viewportWidth);
+	const minimapMaxWidth = Math.floor(options.maxColumn * options.charWidth);
+	const proportionalWidth = Math.floor((availableWidth - 2) * options.charWidth / (options.characterWidth + options.charWidth));
+	return Math.min(minimapMaxWidth, Math.max(0, proportionalWidth) + 2 + 8);
+}
+//#endregion
+//#region src/minimapCharRenderer.ts
+var MinimapCharRenderer = class MinimapCharRenderer {
+	scale;
+	charDataNormal;
+	charDataLight;
+	constructor(charData, scale) {
+		this.scale = scale;
+		this.charDataNormal = MinimapCharRenderer.soften(charData, 12 / 15);
+		this.charDataLight = MinimapCharRenderer.soften(charData, 50 / 60);
+	}
+	renderChar(target, dx, dy, chCode, color, foregroundAlpha, backgroundColor, backgroundAlpha, fontScale, useLighterFont, force1pxHeight) {
+		const charWidth = Constants.BASE_CHAR_WIDTH * this.scale;
+		const charHeight = Constants.BASE_CHAR_HEIGHT * this.scale;
+		const renderHeight = force1pxHeight ? 1 : charHeight;
+		if (dx + charWidth > target.width || dy + renderHeight > target.height) return;
+		this.renderCharData({
+			target,
+			dx,
+			dy,
+			charWidth,
+			renderHeight,
+			charIndex: getCharIndex(chCode, fontScale),
+			color,
+			foregroundAlpha,
+			backgroundColor,
+			backgroundAlpha,
+			charData: useLighterFont ? this.charDataLight : this.charDataNormal
+		});
+	}
+	blockRenderChar(target, dx, dy, color, foregroundAlpha, backgroundColor, backgroundAlpha, force1pxHeight) {
+		const charWidth = Constants.BASE_CHAR_WIDTH * this.scale;
+		const charHeight = Constants.BASE_CHAR_HEIGHT * this.scale;
+		const renderHeight = force1pxHeight ? 1 : charHeight;
+		if (dx + charWidth > target.width || dy + renderHeight > target.height) return;
+		const foregroundRatio = .5 * (foregroundAlpha / 255);
+		const alpha = sourceOverAlpha(backgroundAlpha / 255, foregroundRatio);
+		const blended = sourceOverColor(backgroundColor, color, backgroundAlpha / 255, foregroundRatio, alpha);
+		const destWidth = target.width * Constants.RGBA_CHANNELS_CNT;
+		let row = dy * destWidth + dx * Constants.RGBA_CHANNELS_CNT;
+		for (let y = 0; y < renderHeight; y += 1) {
+			writeBlockRow(target.data, row, charWidth, blended, blended.a);
+			row += destWidth;
+		}
+	}
+	renderCharData(options) {
+		if (options.backgroundAlpha === 0) {
+			this.renderTransparentCharData(options);
+			return;
+		}
+		const dest = options.target.data;
+		const destWidth = options.target.width * Constants.RGBA_CHANNELS_CNT;
+		let sourceOffset = options.charIndex * options.charWidth * Constants.BASE_CHAR_HEIGHT * this.scale;
+		let row = options.dy * destWidth + options.dx * Constants.RGBA_CHANNELS_CNT;
+		for (let y = 0; y < options.renderHeight; y += 1) {
+			sourceOffset = writeCharRow(dest, row, sourceOffset, {
+				charWidth: options.charWidth,
+				charData: options.charData,
+				foregroundAlpha: options.foregroundAlpha,
+				color: options.color,
+				backgroundColor: options.backgroundColor,
+				backgroundAlpha: options.backgroundAlpha
+			});
+			row += destWidth;
+		}
+	}
+	renderTransparentCharData(options) {
+		const dest = options.target.data;
+		const destWidth = options.target.width * Constants.RGBA_CHANNELS_CNT;
+		let sourceOffset = options.charIndex * options.charWidth * Constants.BASE_CHAR_HEIGHT * this.scale;
+		let row = options.dy * destWidth + options.dx * Constants.RGBA_CHANNELS_CNT;
+		for (let y = 0; y < options.renderHeight; y += 1) {
+			sourceOffset = writeTransparentCharRow(dest, row, sourceOffset, {
+				charWidth: options.charWidth,
+				charData: options.charData,
+				foregroundAlpha: options.foregroundAlpha,
+				color: options.color
+			});
+			row += destWidth;
+		}
+	}
+	static soften(input, ratio) {
+		const result = new Uint8ClampedArray(input.length);
+		for (let index = 0; index < input.length; index += 1) result[index] = clamp8(input[index] * ratio);
+		return result;
+	}
+};
+function writeCharRow(dest, row, sourceOffset, options) {
+	let column = row;
+	let source = sourceOffset;
+	for (let x = 0; x < options.charWidth; x += 1) {
+		const c = (options.charData[source] ?? 0) / 255 * (options.foregroundAlpha / 255);
+		source += 1;
+		const alpha = sourceOverAlpha(options.backgroundAlpha / 255, c);
+		const color = sourceOverColor(options.backgroundColor, options.color, options.backgroundAlpha / 255, c, alpha);
+		dest[column++] = color.r;
+		dest[column++] = color.g;
+		dest[column++] = color.b;
+		dest[column++] = clamp8(alpha * 255);
+	}
+	return source;
+}
+function writeTransparentCharRow(dest, row, sourceOffset, options) {
+	let column = row;
+	let source = sourceOffset;
+	for (let x = 0; x < options.charWidth; x += 1) {
+		const coverage = (options.charData[source] ?? 0) / 255 * (options.foregroundAlpha / 255);
+		source += 1;
+		dest[column++] = options.color.r;
+		dest[column++] = options.color.g;
+		dest[column++] = options.color.b;
+		dest[column++] = clamp8(coverage * 255);
+	}
+	return source;
+}
+function sourceOverAlpha(backgroundAlpha, foregroundAlpha) {
+	return foregroundAlpha + backgroundAlpha * (1 - foregroundAlpha);
+}
+function sourceOverColor(background, foreground, backgroundAlpha, foregroundAlpha, alpha) {
+	if (alpha <= 0) return {
+		r: 0,
+		g: 0,
+		b: 0,
+		a: 0
+	};
+	const backgroundRatio = backgroundAlpha * (1 - foregroundAlpha) / alpha;
+	const foregroundRatio = foregroundAlpha / alpha;
+	return {
+		r: clamp8(background.r * backgroundRatio + foreground.r * foregroundRatio),
+		g: clamp8(background.g * backgroundRatio + foreground.g * foregroundRatio),
+		b: clamp8(background.b * backgroundRatio + foreground.b * foregroundRatio),
+		a: clamp8(alpha * 255)
+	};
+}
+function writeBlockRow(dest, row, width, color, alpha) {
+	let column = row;
+	for (let x = 0; x < width; x += 1) {
+		dest[column++] = color.r;
+		dest[column++] = color.g;
+		dest[column++] = color.b;
+		dest[column++] = alpha;
+	}
+}
+//#endregion
+//#region src/minimapCharRendererFactory.ts
+/**
+* Creates minimap character renderers by sampling a normal canvas once and
+* downsampling the glyph data for tiny minimap text rendering.
+*/
+var MinimapCharRendererFactory = class MinimapCharRendererFactory {
+	static lastCreated;
+	static lastFontFamily;
+	static create(scale, fontFamily) {
+		if (this.lastCreated && scale === this.lastCreated.scale && fontFamily === this.lastFontFamily) return this.lastCreated;
+		const renderer = this.createFromSampleData(this.createSampleData(fontFamily).data, scale);
+		this.lastFontFamily = fontFamily;
+		this.lastCreated = renderer;
+		return renderer;
+	}
+	static createSampleData(fontFamily) {
+		const context = createSamplingCanvas().getContext("2d");
+		context.fillStyle = "#ffffff";
+		context.font = `bold ${Constants.SAMPLED_CHAR_HEIGHT}px ${fontFamily}`;
+		context.textBaseline = "middle";
+		let x = 0;
+		for (const code of allCharCodes) {
+			context.fillText(String.fromCharCode(code), x, Constants.SAMPLED_CHAR_HEIGHT / 2);
+			x += Constants.SAMPLED_CHAR_WIDTH;
+		}
+		return context.getImageData(0, 0, Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH, Constants.SAMPLED_CHAR_HEIGHT);
+	}
+	static createFromSampleData(source, scale) {
+		const expectedLength = Constants.SAMPLED_CHAR_HEIGHT * Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT * Constants.CHAR_COUNT;
+		if (source.length !== expectedLength) throw new Error("Unexpected source in MinimapCharRenderer");
+		return new MinimapCharRenderer(MinimapCharRendererFactory.downsample(source, scale), scale);
+	}
+	static downsample(data, scale) {
+		const pixelsPerCharacter = Constants.BASE_CHAR_HEIGHT * scale * Constants.BASE_CHAR_WIDTH * scale;
+		const resultLength = pixelsPerCharacter * Constants.CHAR_COUNT;
+		const result = new Uint8ClampedArray(resultLength);
+		let resultOffset = 0;
+		let sourceOffset = 0;
+		let brightest = 0;
+		for (let index = 0; index < Constants.CHAR_COUNT; index += 1) {
+			brightest = Math.max(brightest, downsampleChar(data, sourceOffset, result, resultOffset, scale));
+			resultOffset += pixelsPerCharacter;
+			sourceOffset += Constants.SAMPLED_CHAR_WIDTH * Constants.RGBA_CHANNELS_CNT;
+		}
+		boostIntensity(result, brightest);
+		return result;
+	}
+};
+function createSamplingCanvas() {
+	return new OffscreenCanvas(Constants.CHAR_COUNT * Constants.SAMPLED_CHAR_WIDTH, Constants.SAMPLED_CHAR_HEIGHT);
+}
+function downsampleChar(source, sourceOffset, dest, destOffset, scale) {
+	const width = Constants.BASE_CHAR_WIDTH * scale;
+	const height = Constants.BASE_CHAR_HEIGHT * scale;
+	let targetIndex = destOffset;
+	let brightest = 0;
+	for (let y = 0; y < height; y += 1) for (let x = 0; x < width; x += 1) {
+		const final = samplePixel(source, sourceOffset, x, y, width, height);
+		brightest = Math.max(brightest, final);
+		dest[targetIndex++] = clamp8(final);
+	}
+	return brightest;
+}
+function samplePixel(source, sourceOffset, x, y, width, height) {
+	const sourceY1 = y / height * Constants.SAMPLED_CHAR_HEIGHT;
+	const sourceY2 = (y + 1) / height * Constants.SAMPLED_CHAR_HEIGHT;
+	const sample = sampleSourceRect(source, sourceOffset, x / width * Constants.SAMPLED_CHAR_WIDTH, (x + 1) / width * Constants.SAMPLED_CHAR_WIDTH, sourceY1, sourceY2);
+	return sample.value / sample.samples;
+}
+function sampleSourceRect(source, sourceOffset, sourceX1, sourceX2, sourceY1, sourceY2) {
+	let value = 0;
+	let samples = 0;
+	for (let sy = sourceY1; sy < sourceY2; sy += 1) {
+		const sampled = sampleSourceRow(source, sourceOffset + Math.floor(sy) * Constants.RGBA_SAMPLED_ROW_WIDTH, sourceX1, sourceX2, 1 - (sy - Math.floor(sy)));
+		value += sampled.value;
+		samples += sampled.samples;
+	}
+	return {
+		value,
+		samples
+	};
+}
+function sampleSourceRow(source, row, sourceX1, sourceX2, yBalance) {
+	let value = 0;
+	let samples = 0;
+	for (let sx = sourceX1; sx < sourceX2; sx += 1) {
+		const xBalance = 1 - (sx - Math.floor(sx));
+		const sourceIndex = row + Math.floor(sx) * Constants.RGBA_CHANNELS_CNT;
+		const weight = xBalance * yBalance;
+		samples += weight;
+		value += (source[sourceIndex] ?? 0) * (source[sourceIndex + 3] ?? 0) / 255 * weight;
+	}
+	return {
+		value,
+		samples
+	};
+}
+function boostIntensity(result, brightest) {
+	if (brightest <= 0) return;
+	const adjust = 255 / brightest;
+	for (let index = 0; index < result.length; index += 1) result[index] = clamp8(result[index] * adjust);
+}
+//#endregion
+//#region src/raster.ts
+var RasterBuffer = class {
+	imageData;
+	pixels;
+	background;
+	constructor(context, width, height, background) {
+		this.imageData = context.createImageData(Math.max(1, width), Math.max(1, height));
+		this.pixels = new Uint32Array(this.imageData.data.buffer);
+		const channels = Uint8ClampedArray.of(background.r, background.g, background.b, background.a);
+		this.background = new Uint32Array(channels.buffer)[0];
+	}
+	clearRows(start, end) {
+		this.pixels.fill(this.background, start * this.imageData.width, end * this.imageData.width);
+	}
+	copyRows(source, destination, count) {
+		const width = this.imageData.width;
+		this.pixels.copyWithin(destination * width, source * width, (source + count) * width);
+	}
+};
+//#endregion
+//#region src/sectionHeaders.ts
+const CHUNK_SIZE = 100;
+function findSectionHeaderDecorations(lines, options) {
+	if (!options.showMarkSectionHeaders) return [];
+	return collectMarkHeaders(lines, options.markSectionHeaderRegex).map(headerToDecoration);
+}
+function findSectionHeaderDecorationsInRange(lines, startLineNumber, options) {
+	return findSectionHeaderDecorations(lines, options).map((decoration) => shiftDecorationLineNumbers(decoration, startLineNumber - 1));
+}
+function collectMarkHeaders(lines, markSectionHeaderRegex) {
+	if (markSectionHeaderRegex.trim() === "") return [];
+	const regex = createHeaderRegex(markSectionHeaderRegex);
+	if (!regex || regExpLeadsToEndlessLoop(regex)) return [];
+	const headers = [];
+	for (let startLine = 1; startLine <= lines.length; startLine += 95) collectHeadersInChunk(headers, lines, startLine, regex);
+	return headers;
+}
+function collectHeadersInChunk(headers, lines, startLine, regex) {
+	const endLine = Math.min(startLine + CHUNK_SIZE - 1, lines.length);
+	const text = lines.slice(startLine - 1, endLine).join("\n");
+	regex.lastIndex = 0;
+	let match;
+	while ((match = regex.exec(text)) !== null) {
+		pushHeader(headers, startLine, text, match);
+		regex.lastIndex = match.index + match[0].length;
+	}
+}
+function pushHeader(headers, startLine, chunkText, match) {
+	const header = matchToSectionHeader(startLine, chunkText, match);
+	if (!header.text && !header.hasSeparatorLine) return;
+	const previous = headers.at(-1);
+	if (previous && previous.endLineNumber >= header.startLineNumber) return;
+	headers.push(header);
+}
+function matchToSectionHeader(startLine, chunkText, match) {
+	const precedingText = chunkText.substring(0, match.index);
+	const lineNumber = startLine + (precedingText.match(/\n/g) || []).length;
+	const matchLines = match[0].split("\n");
+	const matchHeight = matchLines.length;
+	const lineStartIndex = precedingText.lastIndexOf("\n") + 1;
+	const startColumn = match.index - lineStartIndex + 1;
+	const lastMatchLine = matchLines[matchLines.length - 1] ?? "";
+	return {
+		startLineNumber: lineNumber,
+		startColumn,
+		endLineNumber: lineNumber + matchHeight - 1,
+		endColumn: matchHeight === 1 ? startColumn + match[0].length : lastMatchLine.length + 1,
+		text: (match.groups ?? {})["label"] ?? "",
+		hasSeparatorLine: ((match.groups ?? {})["separator"] ?? "") !== ""
+	};
+}
+function headerToDecoration(header) {
+	return {
+		startLineNumber: header.startLineNumber,
+		startColumn: header.startColumn,
+		endLineNumber: header.endLineNumber,
+		endColumn: header.endColumn,
+		position: "inline",
+		sectionHeaderStyle: headerStyle(header.hasSeparatorLine),
+		sectionHeaderText: header.text
+	};
+}
+function shiftDecorationLineNumbers(decoration, lineDelta) {
+	if (lineDelta === 0) return decoration;
+	return {
+		...decoration,
+		startLineNumber: decoration.startLineNumber + lineDelta,
+		endLineNumber: decoration.endLineNumber + lineDelta
+	};
+}
+function headerStyle(hasSeparatorLine) {
+	return hasSeparatorLine ? "underlined" : "normal";
+}
+function createHeaderRegex(source) {
+	try {
+		return new RegExp(source, `gdm${isMultilineRegexSource(source) ? "s" : ""}`);
+	} catch {
+		return null;
+	}
+}
+function isMultilineRegexSource(source) {
+	return source.includes("\\n") || source.includes("\n");
+}
+function regExpLeadsToEndlessLoop(regexp) {
+	regexp.lastIndex = 0;
+	const match = regexp.exec("");
+	regexp.lastIndex = 0;
+	return match !== null && match[0].length === 0;
+}
+//#endregion
+//#region src/renderer.ts
+const EMPTY_DOCUMENT = {
+	textLength: 0,
+	lineStarts: [0],
+	lines: [{
+		text: "",
+		length: 0
+	}],
+	tokens: [],
+	selections: [],
+	decorations: [],
+	externalDecorations: []
+};
+var MinimapWorkerRenderer = class {
+	state = null;
+	init(options) {
+		const mainContext = options.mainCanvas.getContext("2d");
+		const decorationsContext = options.decorationsCanvas.getContext("2d");
+		if (!mainContext || !decorationsContext) throw new Error("Unable to create minimap canvas context");
+		this.state = {
+			mainCanvas: options.mainCanvas,
+			decorationsCanvas: options.decorationsCanvas,
+			mainContext,
+			decorationsContext,
+			options: options.options,
+			styles: options.styles,
+			document: EMPTY_DOCUMENT,
+			externalDecorations: [],
+			metrics: defaultMetrics(),
+			viewport: defaultViewport(),
+			layout: null,
+			previousFrame: null,
+			raster: null,
+			tokenIndex: null,
+			surface: null,
+			linesDirty: true,
+			decorationsDirty: true
+		};
+	}
+	setDocument(document) {
+		if (!this.state) return;
+		const externalDecorations = document.externalDecorations ?? externalDecorationsFrom(document.decorations);
+		const sectionHeaders = findSectionHeaderDecorations(documentLines(document), this.state.options);
+		this.state.externalDecorations = externalDecorations;
+		this.state.document = {
+			...document,
+			decorations: sectionHeaders.concat(externalDecorations),
+			externalDecorations
+		};
+		this.state.previousFrame = null;
+		this.state.linesDirty = true;
+		this.state.decorationsDirty = true;
+	}
+	applyEdit(edit, document) {
+		this.applyEdits([edit], document);
+	}
+	applyEdits(edits, document) {
+		if (!this.state) return;
+		if (edits.length === 0) {
+			this.setSelections(document.selections);
+			return;
+		}
+		const previous = this.state.document;
+		const next = applyTextEditsToMinimapDocument(previous, edits, document.summaryPatch);
+		this.setEditedDocument(previous, next, edits, document.selections);
+	}
+	setExternalDecorations(decorations) {
+		if (!this.state) return;
+		this.state.externalDecorations = decorations;
+		this.state.document = {
+			...this.state.document,
+			externalDecorations: decorations,
+			decorations: sectionHeaderDecorationsFrom(this.state.document.decorations).concat(decorations)
+		};
+		this.state.decorationsDirty = true;
+	}
+	setEditedDocument(previous, document, edits, selections) {
+		const state = this.requireState();
+		const decorations = updateSectionHeaderDecorations(previous, document, edits, state.options).concat(state.externalDecorations);
+		state.document = {
+			textLength: document.textLength,
+			lineStarts: document.lineStarts,
+			lines: document.lines,
+			tokens: document.tokens,
+			selections,
+			decorations,
+			externalDecorations: state.externalDecorations
+		};
+		state.linesDirty = true;
+		state.decorationsDirty = true;
+	}
+	setBaseStyles(styles) {
+		if (!this.state) return;
+		this.state.styles = styles;
+		this.state.raster = null;
+		this.state.linesDirty = true;
+		this.state.decorationsDirty = true;
+	}
+	setTokens(tokens) {
+		if (!this.state) return;
+		this.state.document = {
+			...this.state.document,
+			tokens
+		};
+		this.state.linesDirty = true;
+	}
+	updateTokenRange(patch) {
+		if (!this.state) return;
+		const tokens = replaceTokenRange(this.state.document.tokens, patch);
+		this.state.document = {
+			...this.state.document,
+			tokens
+		};
+		this.state.linesDirty = true;
+	}
+	setSelections(selections) {
+		if (!this.state) return;
+		this.state.document = {
+			...this.state.document,
+			selections
+		};
+		this.state.decorationsDirty = true;
+	}
+	setDecorations(decorations) {
+		if (!this.state) return;
+		this.state.externalDecorations = externalDecorationsFrom(decorations);
+		this.state.document = {
+			...this.state.document,
+			decorations
+		};
+		this.state.decorationsDirty = true;
+	}
+	updateLayout(metrics, viewport) {
+		if (!this.state) return null;
+		this.state.metrics = metrics;
+		this.state.viewport = viewport;
+		const nextLayout = this.createRenderLayout();
+		const layoutChanged = !this.state.layout || !renderLayoutsEqual(this.state.layout, nextLayout);
+		this.state.layout = nextLayout;
+		if (layoutChanged) {
+			this.state.linesDirty = true;
+			this.state.decorationsDirty = true;
+			this.state.previousFrame = null;
+		}
+		this.resizeCanvases(this.state.layout);
+		return this.state.layout;
+	}
+	updateViewport(viewport) {
+		if (!this.state) return null;
+		const previous = this.state.layout;
+		const next = this.updateLayout(this.state.metrics, viewport);
+		if (!next || previous && renderLayoutsEqual(previous, next)) return null;
+		return next;
+	}
+	render() {
+		if (!this.state) return null;
+		const layout = this.state.layout ?? this.createRenderLayout();
+		this.state.layout = layout;
+		this.resizeCanvases(layout);
+		if (layout.renderMinimap === RenderMinimap.None) return emptyRenderResult();
+		const frame = computeFrameLayout({
+			renderLayout: layout,
+			metrics: this.state.metrics,
+			viewport: this.state.viewport,
+			lineCount: this.minimapLineCount(layout),
+			realLineCount: this.state.document.lineStarts.length,
+			previous: this.state.previousFrame
+		});
+		const frameChanged = !this.state.previousFrame || !framesPaintSameWindow(this.state.previousFrame, frame);
+		const surface = this.surfaceForLayout(layout);
+		if (this.state.linesDirty || frameChanged) this.renderLines(layout, frame, surface.mainContext);
+		if (this.state.decorationsDirty || frameChanged) this.renderDecorations(layout, frame, surface.decorationsContext);
+		this.presentSurface(layout, frame, surface);
+		this.state.previousFrame = frame;
+		this.state.linesDirty = false;
+		this.state.decorationsDirty = false;
+		return {
+			sliderNeeded: frame.sliderNeeded,
+			sliderTop: frame.sliderTop,
+			sliderHeight: frame.sliderHeight,
+			shadowVisible: this.state.viewport.scrollLeft + this.state.viewport.clientWidth < this.state.viewport.scrollWidth
+		};
+	}
+	dispose() {
+		this.state = null;
+	}
+	createRenderLayout() {
+		const state = this.requireState();
+		return computeRenderLayout({
+			minimap: state.options,
+			metrics: state.metrics,
+			viewport: state.viewport,
+			lineCount: state.document.lineStarts.length
+		});
+	}
+	renderLines(layout, frame, context) {
+		const state = this.requireState();
+		const raster = this.rasterForLayout(layout, context);
+		const previous = state.linesDirty ? null : state.previousFrame;
+		const reusedStart = Math.max(frame.startLineNumber, previous?.startLineNumber ?? Infinity);
+		const reusedEnd = Math.min(frame.endLineNumber, previous?.endLineNumber ?? -Infinity);
+		if (previous && reusedStart <= reusedEnd) {
+			const sourceY = yForLineNumber(previous, reusedStart, layout.lineHeight);
+			const destinationY = yForLineNumber(frame, reusedStart, layout.lineHeight);
+			const reusedHeight = (reusedEnd - reusedStart + 1) * layout.lineHeight;
+			raster.copyRows(sourceY, destinationY, reusedHeight);
+			raster.clearRows(0, destinationY);
+			raster.clearRows(destinationY + reusedHeight, raster.imageData.height);
+			this.renderLineRange(layout, frame, raster.imageData, frame.startLineNumber, reusedStart - 1);
+			this.renderLineRange(layout, frame, raster.imageData, reusedEnd + 1, frame.endLineNumber);
+		} else {
+			raster.clearRows(0, raster.imageData.height);
+			this.renderLineRange(layout, frame, raster.imageData, frame.startLineNumber, frame.endLineNumber);
+		}
+		context.putImageData(raster.imageData, 0, 0);
+	}
+	rasterForLayout(layout, context) {
+		const state = this.requireState();
+		const width = Math.max(1, layout.canvasInnerWidth);
+		const height = rasterHeight(layout);
+		if (state.raster?.imageData.width === width && state.raster.imageData.height === height) return state.raster;
+		state.raster = new RasterBuffer(context, width, height, state.styles.minimapBackground);
+		return state.raster;
+	}
+	renderLineRange(layout, frame, imageData, startLineNumber, endLineNumber) {
+		if (startLineNumber > endLineNumber) return;
+		const state = this.requireState();
+		const charRenderer = MinimapCharRendererFactory.create(layout.scale, state.styles.fontFamily);
+		const useLighterFont = relativeLuminance(state.styles.background) >= .5;
+		const renderBackground = state.styles.background;
+		let tokenCursor = this.tokenCursorForOffset(this.lineStartOffset(this.documentLineForRasterLine(layout, startLineNumber)));
+		for (let line = startLineNumber; line <= endLineNumber; line += 1) {
+			const documentLine = this.documentLineForRasterLine(layout, line);
+			const text = this.lineText(documentLine);
+			const lineStart = this.lineStartOffset(documentLine);
+			const lineEnd = lineStart + text.length;
+			const lineTokens = tokensForLineFromCursor(state.document.tokens, lineStart, lineEnd, tokenCursor);
+			tokenCursor = lineTokens.cursor;
+			this.renderLine({
+				imageData,
+				layout,
+				frame,
+				line,
+				text,
+				lineStart,
+				tokens: state.document.tokens,
+				tokenEnd: lineTokens.end,
+				tokenStart: lineTokens.start,
+				charRenderer,
+				useLighterFont,
+				renderBackground,
+				renderBackgroundAlpha: state.styles.minimapBackground.a
+			});
+		}
+	}
+	tokenCursorForOffset(offset) {
+		const state = this.requireState();
+		const tokens = state.document.tokens;
+		if (state.tokenIndex?.tokens !== tokens) state.tokenIndex = {
+			tokens,
+			maxEnds: tokenMaxEnds(tokens)
+		};
+		return firstTokenEndingAfter(state.tokenIndex.maxEnds, offset);
+	}
+	renderLine(options) {
+		const state = this.requireState();
+		const y = yForLineNumber(options.frame, options.line, options.layout.lineHeight);
+		const maxDx = options.layout.canvasInnerWidth - options.layout.charWidth;
+		let dx = 2;
+		visitTokenSegments(options.text, options.lineStart, options.tokens, options.tokenStart, options.tokenEnd, state.styles.foreground, (text, color) => {
+			if (dx > maxDx) return false;
+			dx = renderSegment({
+				...options,
+				text,
+				color,
+				dx,
+				y,
+				maxDx
+			});
+			return dx <= maxDx;
+		});
+	}
+	renderDecorations(layout, frame, context) {
+		context.clearRect(0, 0, layout.canvasInnerWidth, rasterHeight(layout));
+		const lineCount = this.requireState().document.lineStarts.length;
+		const decorationLayout = layout.isSampling ? {
+			...layout,
+			lineHeight: layout.canvasInnerHeight / Math.max(1, lineCount)
+		} : layout;
+		const decorationFrame = layout.isSampling ? {
+			...frame,
+			endLineNumber: lineCount
+		} : frame;
+		this.renderSelectionHighlights(decorationLayout, decorationFrame, context);
+		this.renderMinimapDecorations(decorationLayout, decorationFrame, context);
+		this.renderSectionHeaders(decorationLayout, decorationFrame, context);
+	}
+	renderSelectionHighlights(layout, frame, context) {
+		const state = this.requireState();
+		context.fillStyle = rgbaToCss(transparent(state.styles.selection, .5));
+		for (const selection of state.document.selections) {
+			const range = this.offsetRangeToLineRange(selection.startOffset, selection.endOffset);
+			fillLineRange(context, layout, frame, range.start, range.end);
+		}
+	}
+	renderMinimapDecorations(layout, frame, context) {
+		const state = this.requireState();
+		const decorations = state.document.decorations.filter((decoration) => !decoration.sectionHeaderStyle).toSorted((left, right) => (left.zIndex ?? 0) - (right.zIndex ?? 0));
+		for (const decoration of decorations) {
+			context.fillStyle = rgbaToCss(transparent(parseCssColor(decoration.color, state.styles.selection), .5));
+			fillDecorationRange(context, layout, frame, decoration);
+		}
+	}
+	renderSectionHeaders(layout, frame, context) {
+		const state = this.requireState();
+		const fontSize = state.options.sectionHeaderFontSize * state.metrics.devicePixelRatio;
+		context.font = `500 ${fontSize}px ${state.styles.fontFamily}`;
+		context.fillStyle = rgbaToCss(transparent(state.styles.minimapBackground, .7));
+		context.strokeStyle = rgbaToCss(state.styles.foreground);
+		context.lineWidth = .4;
+		for (const decoration of state.document.decorations) {
+			if (!decoration.sectionHeaderStyle) continue;
+			renderSectionHeader(context, decoration, layout, frame, fontSize, state.styles.foreground);
+		}
+	}
+	minimapLineCount(layout) {
+		const state = this.requireState();
+		if (!layout.isSampling) return state.document.lineStarts.length;
+		return Math.max(1, Math.min(state.document.lineStarts.length, layout.canvasInnerHeight));
+	}
+	documentLineForRasterLine(layout, line) {
+		if (!layout.isSampling) return line;
+		const count = this.requireState().document.lineStarts.length;
+		return Math.floor((line - 1) * count / this.minimapLineCount(layout)) + 1;
+	}
+	lineText(lineNumber) {
+		return this.requireState().document.lines[lineNumber - 1]?.text ?? "";
+	}
+	lineStartOffset(lineNumber) {
+		const state = this.requireState();
+		return state.document.lineStarts[lineNumber - 1] ?? state.document.textLength;
+	}
+	offsetRangeToLineRange(startOffset, endOffset) {
+		return {
+			start: this.lineNumberForOffset(startOffset),
+			end: this.lineNumberForOffset(endOffset)
+		};
+	}
+	lineNumberForOffset(offset) {
+		const state = this.requireState();
+		let low = 0;
+		let high = state.document.lineStarts.length - 1;
+		const clamped = Math.max(0, Math.min(offset, state.document.textLength));
+		while (low <= high) {
+			const middle = Math.floor((low + high) / 2);
+			const start = state.document.lineStarts[middle] ?? 0;
+			const next = state.document.lineStarts[middle + 1] ?? Number.POSITIVE_INFINITY;
+			if (clamped < start) high = middle - 1;
+			else if (clamped >= next) low = middle + 1;
+			else return middle + 1;
+		}
+		return state.document.lineStarts.length;
+	}
+	resizeCanvases(layout) {
+		const state = this.requireState();
+		resizeCanvas(state.mainCanvas, layout.canvasInnerWidth, layout.canvasInnerHeight);
+		resizeCanvas(state.decorationsCanvas, layout.canvasInnerWidth, layout.canvasInnerHeight);
+	}
+	surfaceForLayout(layout) {
+		const state = this.requireState();
+		state.surface ??= createRasterSurface();
+		resizeCanvas(state.surface.mainCanvas, layout.canvasInnerWidth, rasterHeight(layout));
+		resizeCanvas(state.surface.decorationsCanvas, layout.canvasInnerWidth, rasterHeight(layout));
+		return state.surface;
+	}
+	presentSurface(layout, frame, surface) {
+		const state = this.requireState();
+		const offsetY = Math.round(frame.startLineFraction * layout.lineHeight);
+		presentRaster(state.mainContext, surface.mainCanvas, state.mainCanvas, offsetY);
+		presentRaster(state.decorationsContext, surface.decorationsCanvas, state.decorationsCanvas, offsetY);
+	}
+	requireState() {
+		if (!this.state) throw new Error("Minimap renderer is not initialized");
+		return this.state;
+	}
+};
+function createRasterSurface() {
+	const mainCanvas = new OffscreenCanvas(1, 1);
+	const decorationsCanvas = new OffscreenCanvas(1, 1);
+	const mainContext = mainCanvas.getContext("2d");
+	const decorationsContext = decorationsCanvas.getContext("2d");
+	if (!mainContext || !decorationsContext) throw createError({
+		message: "Unable to create minimap raster surface",
+		code: "MINIMAP_RASTER_CONTEXT",
+		status: 500,
+		why: "The browser did not provide a 2D context for the minimap raster.",
+		fix: "Check OffscreenCanvas 2D support and canvas resource limits."
+	});
+	return {
+		mainCanvas,
+		decorationsCanvas,
+		mainContext,
+		decorationsContext
+	};
+}
+function rasterHeight(layout) {
+	return Math.max(1, (Math.ceil(layout.canvasInnerHeight / layout.lineHeight) + 1) * layout.lineHeight);
+}
+function presentRaster(context, source, target, offsetY) {
+	context.globalCompositeOperation = "copy";
+	context.imageSmoothingEnabled = true;
+	context.drawImage(source, 0, offsetY, target.width, target.height, 0, 0, target.width, target.height);
+}
+function renderSegment(options) {
+	let dx = options.dx;
+	for (let index = 0; index < options.text.length; index += 1) {
+		if (dx > options.maxDx) return dx;
+		dx = renderCharacter(options, dx, options.text.charCodeAt(index));
+	}
+	return dx;
+}
+function renderCharacter(options, dx, code) {
+	if (code === 9) return dx + 4 * options.layout.charWidth;
+	if (code === 32) return dx + options.layout.charWidth;
+	if (options.layout.renderMinimap === RenderMinimap.Blocks) {
+		options.charRenderer.blockRenderChar(options.imageData, dx, options.y, options.color, 255, options.renderBackground, options.renderBackgroundAlpha, options.layout.lineHeight === 1);
+		return dx + options.layout.charWidth;
+	}
+	options.charRenderer.renderChar(options.imageData, dx, options.y, code, options.color, 255, options.renderBackground, options.renderBackgroundAlpha, options.layout.scale, options.useLighterFont, options.layout.lineHeight === 1);
+	return dx + options.layout.charWidth;
+}
+function visitTokenSegments(text, lineStart, tokens, tokenStart, tokenEnd, fallback, visit) {
+	let cursor = 0;
+	for (let index = tokenStart; index < tokenEnd; index += 1) {
+		const token = tokens[index];
+		const start = Math.max(0, token.start - lineStart);
+		const end = Math.min(text.length, token.end - lineStart);
+		if (start > cursor && !visit(text.slice(cursor, start), fallback)) return;
+		if (end > start && !visit(text.slice(start, end), token.color)) return;
+		cursor = Math.max(cursor, end);
+	}
+	if (cursor < text.length) visit(text.slice(cursor), fallback);
+}
+function tokensForLineFromCursor(tokens, lineStart, lineEnd, cursor) {
+	let index = cursor;
+	while (index < tokens.length && tokens[index].end <= lineStart) index += 1;
+	const start = index;
+	while (index < tokens.length && tokens[index].start < lineEnd) index += 1;
+	return {
+		start,
+		end: index,
+		cursor: start
+	};
+}
+function tokenMaxEnds(tokens) {
+	const maxEnds = new Float64Array(tokens.length);
+	let maxEnd = 0;
+	for (let index = 0; index < tokens.length; index += 1) {
+		maxEnd = Math.max(maxEnd, tokens[index].end);
+		maxEnds[index] = maxEnd;
+	}
+	return maxEnds;
+}
+function firstTokenEndingAfter(maxEnds, offset) {
+	let low = 0;
+	let high = maxEnds.length;
+	while (low < high) {
+		const middle = Math.floor((low + high) / 2);
+		if (maxEnds[middle] <= offset) {
+			low = middle + 1;
+			continue;
+		}
+		high = middle;
+	}
+	return low;
+}
+function fillLineRange(context, layout, frame, startLineNumber, endLineNumber) {
+	const start = Math.max(frame.startLineNumber, startLineNumber);
+	const end = Math.min(frame.endLineNumber, endLineNumber);
+	if (start > end) return;
+	const y = yForLineNumber(frame, start, layout.lineHeight);
+	const height = Math.max(layout.lineHeight, yForLineNumber(frame, end, layout.lineHeight) - y + layout.lineHeight);
+	context.fillRect(2, y, layout.canvasInnerWidth, height);
+}
+function fillDecorationRange(context, layout, frame, decoration) {
+	if (decoration.position === "gutter") {
+		fillGutterLineRange(context, layout, frame, decoration.startLineNumber, decoration.endLineNumber);
+		return;
+	}
+	fillLineRange(context, layout, frame, decoration.startLineNumber, decoration.endLineNumber);
+}
+function fillGutterLineRange(context, layout, frame, startLineNumber, endLineNumber) {
+	const range = visibleLineRange(frame, startLineNumber, endLineNumber);
+	if (!range) return;
+	const y = yForLineNumber(frame, range.start, layout.lineHeight);
+	const height = lineRangeHeight(layout, frame, range.end, y);
+	const width = minimapRightGutterWidth(layout);
+	context.fillRect(layout.canvasInnerWidth - width, y, width, height);
+}
+function visibleLineRange(frame, startLineNumber, endLineNumber) {
+	const start = Math.max(frame.startLineNumber, startLineNumber);
+	const end = Math.min(frame.endLineNumber, endLineNumber);
+	if (start > end) return null;
+	return {
+		start,
+		end
+	};
+}
+function lineRangeHeight(layout, frame, endLineNumber, y) {
+	return Math.max(layout.lineHeight, yForLineNumber(frame, endLineNumber, layout.lineHeight) - y + layout.lineHeight);
+}
+function minimapRightGutterWidth(layout) {
+	const horizontalScale = layout.canvasInnerWidth / Math.max(1, layout.canvasOuterWidth);
+	return Math.max(2, Math.ceil(8 * horizontalScale));
+}
+function renderSectionHeader(context, decoration, layout, frame, fontSize, color) {
+	if (decoration.startLineNumber < frame.startLineNumber || decoration.startLineNumber > frame.endLineNumber) return;
+	const y = yForLineNumber(frame, decoration.startLineNumber, layout.lineHeight) + fontSize;
+	context.fillRect(0, y - fontSize, layout.canvasInnerWidth, fontSize * 1.5);
+	context.fillStyle = rgbaToCss(color);
+	if (decoration.sectionHeaderText) context.fillText(decoration.sectionHeaderText, 2, y, layout.canvasInnerWidth);
+	if (decoration.sectionHeaderStyle === "underlined") {
+		context.beginPath();
+		context.moveTo(0, y - fontSize + 2);
+		context.lineTo(layout.canvasInnerWidth, y - fontSize + 2);
+		context.stroke();
+	}
+}
+function resizeCanvas(canvas, width, height) {
+	const safeWidth = Math.max(1, width);
+	const safeHeight = Math.max(1, height);
+	if (canvas.width !== safeWidth) canvas.width = safeWidth;
+	if (canvas.height !== safeHeight) canvas.height = safeHeight;
+}
+function renderLayoutsEqual(left, right) {
+	return left.width === right.width && left.height === right.height && left.canvasInnerWidth === right.canvasInnerWidth && left.canvasInnerHeight === right.canvasInnerHeight && left.lineHeight === right.lineHeight && left.charWidth === right.charWidth && left.scale === right.scale && left.isSampling === right.isSampling && left.heightIsEditorHeight === right.heightIsEditorHeight && left.renderMinimap === right.renderMinimap;
+}
+function framesPaintSameWindow(left, right) {
+	return left.startLineNumber === right.startLineNumber && left.endLineNumber === right.endLineNumber && left.topPaddingLineCount === right.topPaddingLineCount;
+}
+function defaultMetrics() {
+	return {
+		rowHeight: 20,
+		characterWidth: 8,
+		devicePixelRatio: 1
+	};
+}
+function defaultViewport() {
+	return {
+		scrollTop: 0,
+		scrollRow: 0,
+		scrollLeft: 0,
+		scrollHeight: 0,
+		scrollWidth: 0,
+		clientHeight: 0,
+		clientWidth: 0,
+		minimapHeight: 0,
+		visibleStart: 0,
+		reservedWidth: 0,
+		visibleEnd: 1
+	};
+}
+function emptyRenderResult() {
+	return {
+		sliderNeeded: false,
+		sliderTop: 0,
+		sliderHeight: 0,
+		shadowVisible: false
+	};
+}
+function applyTextEditsToMinimapDocument(document, edits, summaryPatch) {
+	let tokens = document.tokens;
+	for (const edit of edits) tokens = projectMinimapTokensThroughEdit(tokens, edit, tokenProjectionText(document));
+	return {
+		...applyMinimapDocumentSummaryPatch(document, summaryPatch),
+		tokens
+	};
+}
+function applyMinimapDocumentSummaryPatch(document, patch) {
+	const startLine = Math.min(Math.max(0, patch.startLine), document.lines.length);
+	const deleteCount = Math.min(Math.max(0, patch.deleteCount), document.lines.length - startLine);
+	return {
+		textLength: patch.textLength,
+		lineStarts: patch.lineStarts ?? splicedLineStarts(document, patch, startLine, deleteCount),
+		lines: document.lines.slice(0, startLine).concat(patch.lines, document.lines.slice(startLine + deleteCount))
+	};
+}
+function splicedLineStarts(document, patch, startLine, deleteCount) {
+	const previous = document.lineStarts;
+	const next = previous.slice(0, startLine);
+	let cursor = lineStartAt(previous, document.lines, startLine);
+	for (const line of patch.lines) {
+		next.push(cursor);
+		cursor += line.length + 1;
+	}
+	const delta = patch.textLength - document.textLength;
+	for (let index = startLine + deleteCount; index < previous.length; index += 1) next.push(previous[index] + delta);
+	return next;
+}
+function lineStartAt(lineStarts, lines, line) {
+	const existing = lineStarts[line];
+	if (existing !== void 0) return existing;
+	if (line === 0) return 0;
+	return (lineStarts[line - 1] ?? 0) + (lines[line - 1]?.length ?? 0) + 1;
+}
+function lineIndexForOffset(lineStarts, offset) {
+	let low = 0;
+	let high = lineStarts.length - 1;
+	const clamped = Math.max(0, offset);
+	while (low <= high) {
+		const middle = Math.floor((low + high) / 2);
+		const start = lineStarts[middle] ?? 0;
+		const next = lineStarts[middle + 1] ?? Number.POSITIVE_INFINITY;
+		if (clamped < start) {
+			high = middle - 1;
+			continue;
+		}
+		if (clamped >= next) {
+			low = middle + 1;
+			continue;
+		}
+		return middle;
+	}
+	return Math.max(0, lineStarts.length - 1);
+}
+const SECTION_HEADER_EDIT_CONTEXT_LINES = 10;
+function updateSectionHeaderDecorations(previous, next, edits, options) {
+	if (!options.showMarkSectionHeaders) return [];
+	if (edits.length === 0) return sectionHeaderDecorationsFrom(previous.decorations);
+	const oldRange = affectedOldLineRange(previous.lineStarts, edits);
+	const nextRange = affectedNextLineRange(next.lineStarts, edits);
+	const lineDelta = next.lineStarts.length - previous.lineStarts.length;
+	const shifted = shiftedSectionHeaders(previous.decorations, oldRange, nextRange, lineDelta);
+	const rescanned = rescanSectionHeaders(next, nextRange, options);
+	return shifted.concat(rescanned).sort(compareDecorationsByLine);
+}
+function affectedOldLineRange(lineStarts, edits) {
+	let start = Number.POSITIVE_INFINITY;
+	let end = 1;
+	for (const edit of edits) {
+		start = Math.min(start, lineIndexForOffset(lineStarts, edit.from) + 1);
+		end = Math.max(end, lineIndexForOffset(lineStarts, edit.to) + 1);
+	}
+	return expandLineRange({
+		start,
+		end
+	}, lineStarts.length);
+}
+function affectedNextLineRange(lineStarts, edits) {
+	let start = Number.POSITIVE_INFINITY;
+	let end = 1;
+	for (const edit of edits) {
+		start = Math.min(start, lineIndexForOffset(lineStarts, edit.from) + 1);
+		end = Math.max(end, lineIndexForOffset(lineStarts, edit.from + edit.text.length) + 1);
+	}
+	return expandLineRange({
+		start,
+		end
+	}, lineStarts.length);
+}
+function expandLineRange(range, lineCount) {
+	return {
+		start: Math.max(1, range.start - SECTION_HEADER_EDIT_CONTEXT_LINES),
+		end: Math.min(lineCount, range.end + SECTION_HEADER_EDIT_CONTEXT_LINES)
+	};
+}
+function shiftedSectionHeaders(decorations, oldRange, nextRange, lineDelta) {
+	return sectionHeaderDecorationsFrom(decorations).flatMap((decoration) => shiftSectionHeaderDecoration(decoration, oldRange, nextRange, lineDelta));
+}
+function shiftSectionHeaderDecoration(decoration, oldRange, nextRange, lineDelta) {
+	if (lineRangesIntersect(decoration, oldRange)) return [];
+	if (decoration.startLineNumber <= oldRange.end) return lineRangesIntersect(decoration, nextRange) ? [] : [decoration];
+	const shifted = shiftDecoration(decoration, lineDelta);
+	return lineRangesIntersect(shifted, nextRange) ? [] : [shifted];
+}
+function shiftDecoration(decoration, lineDelta) {
+	if (lineDelta === 0) return decoration;
+	return {
+		...decoration,
+		startLineNumber: decoration.startLineNumber + lineDelta,
+		endLineNumber: decoration.endLineNumber + lineDelta
+	};
+}
+function rescanSectionHeaders(document, range, options) {
+	return findSectionHeaderDecorationsInRange(linesForRange(document.lines, range), range.start, options);
+}
+function linesForRange(summaries, range) {
+	const lines = [];
+	for (let lineNumber = range.start; lineNumber <= range.end; lineNumber += 1) lines.push(summaries[lineNumber - 1]?.text ?? "");
+	return lines;
+}
+function lineRangesIntersect(decoration, range) {
+	return decoration.startLineNumber <= range.end && decoration.endLineNumber >= range.start;
+}
+function compareDecorationsByLine(left, right) {
+	return left.startLineNumber - right.startLineNumber || left.endLineNumber - right.endLineNumber;
+}
+function externalDecorationsFrom(decorations) {
+	return decorations.filter((decoration) => !decoration.sectionHeaderStyle);
+}
+function sectionHeaderDecorationsFrom(decorations) {
+	return decorations.filter((decoration) => decoration.sectionHeaderStyle);
+}
+function replaceTokenRange(tokens, patch) {
+	const start = clampTokenIndex(patch.start, tokens.length);
+	const deleteEnd = clampTokenIndex(start + patch.deleteCount, tokens.length);
+	return tokens.slice(0, start).concat(patch.tokens, tokens.slice(deleteEnd));
+}
+function clampTokenIndex(index, length) {
+	return Math.min(length, Math.max(0, index));
+}
+function projectMinimapTokensThroughEdit(tokens, edit, previousText) {
+	const delta = edit.text.length - (edit.to - edit.from);
+	const projected = [];
+	for (const token of tokens) {
+		const next = projectMinimapTokenThroughEdit(token, edit, previousText, delta);
+		if (isRenderableMinimapToken(next)) projected.push(next);
+	}
+	return projected;
+}
+function projectMinimapTokenThroughEdit(token, edit, previousText, delta) {
+	if (edit.from === edit.to) return projectMinimapTokenThroughInsertion(token, edit, previousText);
+	if (token.end <= edit.from) return token;
+	if (token.start >= edit.to) return shiftMinimapToken(token, delta);
+	if (!canResizeMinimapTokenAcrossEdit(token, edit)) return null;
+	return {
+		...token,
+		end: token.end + delta
+	};
+}
+function projectMinimapTokenThroughInsertion(token, edit, previousText) {
+	if (shouldExpandMinimapTokenForInsertion(token, edit, previousText)) return {
+		...token,
+		end: token.end + edit.text.length
+	};
+	if (token.start >= edit.from) return shiftMinimapToken(token, edit.text.length);
+	return token;
+}
+function canResizeMinimapTokenAcrossEdit(token, edit) {
+	if (edit.text.includes("\n")) return false;
+	return token.start < edit.from && edit.to < token.end;
+}
+function shouldExpandMinimapTokenForInsertion(token, edit, previousText) {
+	if (edit.text.length === 0) return false;
+	if (edit.text.includes("\n")) return false;
+	if (token.start < edit.from && edit.from < token.end) return true;
+	if (!isWordLikeText(edit.text)) return false;
+	if (token.end === edit.from) return textHasWordBeforeOffset(previousText, edit.from);
+	if (token.start === edit.from) return !textHasWordBeforeOffset(previousText, edit.from) && textHasWordCodePointAt(previousText, edit.from);
+	return false;
+}
+function shiftMinimapToken(token, delta) {
+	return {
+		...token,
+		start: token.start + delta,
+		end: token.end + delta
+	};
+}
+function isRenderableMinimapToken(token) {
+	if (!token) return false;
+	return token.end > token.start;
+}
+function isWordLikeText(text) {
+	return /^[\p{L}\p{N}_]+$/u.test(text);
+}
+function tokenProjectionText(document) {
+	return {
+		isWordBeforeOffset: (offset) => summaryHasWordBeforeOffset(document, offset),
+		isWordCodePointAt: (offset) => summaryHasWordCodePointAt(document, offset)
+	};
+}
+function documentLines(document) {
+	return document.lines.map((line) => line.text);
+}
+function textHasWordBeforeOffset(text, offset) {
+	if (typeof text !== "string") return text.isWordBeforeOffset(offset);
+	return stringHasWordBeforeOffset(text, offset);
+}
+function textHasWordCodePointAt(text, offset) {
+	if (typeof text !== "string") return text.isWordCodePointAt(offset);
+	return stringHasWordCodePointAt(text, offset);
+}
+function summaryHasWordBeforeOffset(document, offset) {
+	const location = summaryOffsetLocation(document, offset);
+	if (!location) return false;
+	return stringHasWordBeforeOffset(location.text, location.localOffset);
+}
+function summaryHasWordCodePointAt(document, offset) {
+	const location = summaryOffsetLocation(document, offset);
+	if (!location) return false;
+	return stringHasWordCodePointAt(location.text, location.localOffset);
+}
+function summaryOffsetLocation(document, offset) {
+	const clamped = Math.max(0, Math.min(offset, document.textLength));
+	const lineIndex = lineIndexForOffset(document.lineStarts, clamped);
+	const lineStart = document.lineStarts[lineIndex] ?? 0;
+	const text = document.lines[lineIndex]?.text ?? "";
+	const localOffset = clamped - lineStart;
+	if (localOffset < 0 || localOffset > text.length) return null;
+	return {
+		text,
+		localOffset
+	};
+}
+function stringHasWordBeforeOffset(text, offset) {
+	const previous = previousCodePointStart(text, offset);
+	if (previous === null) return false;
+	return stringHasWordCodePointAt(text, previous);
+}
+function stringHasWordCodePointAt(text, offset) {
+	const codePoint = text.codePointAt(offset);
+	if (codePoint === void 0) return false;
+	return /^[\p{L}\p{N}_]$/u.test(String.fromCodePoint(codePoint));
+}
+function previousCodePointStart(text, offset) {
+	if (offset <= 0) return null;
+	const previous = offset - 1;
+	const codeUnit = text.charCodeAt(previous);
+	const beforePrevious = previous - 1;
+	if (!(codeUnit >= 56320 && codeUnit <= 57343) || beforePrevious < 0) return previous;
+	const previousCodeUnit = text.charCodeAt(beforePrevious);
+	return previousCodeUnit >= 55296 && previousCodeUnit <= 56319 ? beforePrevious : previous;
+}
+//#endregion
+//#region src/minimap.worker.ts
+const renderer = new MinimapWorkerRenderer();
+globalThis.onmessage = (event) => {
+	const request = event.data;
+	try {
+		measureWorkerRequest(request, () => handleRequest(request));
+	} catch (error) {
+		post({
+			type: "error",
+			message: errorMessage(error)
+		});
+	}
+};
+function handleRequest(request) {
+	switch (request.type) {
+		case "init":
+			renderer.init({
+				mainCanvas: request.mainCanvas,
+				decorationsCanvas: request.decorationsCanvas,
+				options: request.options,
+				styles: request.baseStyles
+			});
+			return;
+		case "updateBaseStyles":
+			renderer.setBaseStyles(request.baseStyles);
+			return;
+		case "openDocument":
+		case "replaceDocument":
+			renderer.setDocument(request.document);
+			return;
+		case "applyEdit":
+			renderer.applyEdit(request.edit, request.document);
+			return;
+		case "applyEdits":
+			renderer.applyEdits(request.edits, request.document);
+			return;
+		case "updateTokens":
+			renderer.setTokens(request.tokens);
+			return;
+		case "updateTokenRange":
+			renderer.updateTokenRange(request.patch);
+			return;
+		case "updateSelection":
+			renderer.setSelections(request.selections);
+			return;
+		case "updateDecorations":
+			renderer.setDecorations(request.decorations);
+			return;
+		case "updateExternalDecorations":
+			renderer.setExternalDecorations(request.decorations);
+			return;
+		case "updateLayout": {
+			const layout = renderer.updateLayout(request.metrics, request.viewport);
+			if (layout) post({
+				type: "layout",
+				sequence: 0,
+				layout
+			});
+			return;
+		}
+		case "updateViewport": {
+			const layout = renderer.updateViewport(request.viewport);
+			if (layout) post({
+				type: "layout",
+				sequence: 0,
+				layout
+			});
+			return;
+		}
+		case "render":
+			postRender(request.sequence);
+			return;
+		case "dispose":
+			renderer.dispose();
+			post({ type: "disposed" });
+			return;
+	}
+}
+function postRender(sequence) {
+	const result = renderer.render();
+	if (!result) return;
+	post({
+		type: "rendered",
+		sequence,
+		sliderNeeded: result.sliderNeeded,
+		sliderTop: result.sliderTop,
+		sliderHeight: result.sliderHeight,
+		shadowVisible: result.shadowVisible
+	});
+}
+function post(response) {
+	globalThis.postMessage(response);
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	return String(error);
+}
+function measureWorkerRequest(request, run) {
+	const sink = minimapWorkerDiagnosticSink();
+	if (!sink) {
+		run();
+		return;
+	}
+	const start = nowMs();
+	try {
+		run();
+	} finally {
+		recordMinimapWorkerDiagnostic(sink, {
+			name: "minimap.worker.request",
+			durationMs: nowMs() - start,
+			detail: { request: request.type }
+		});
+	}
+}
+function minimapWorkerDiagnosticSink() {
+	const sink = minimapWorkerDiagnosticGlobal().__EDITOR_PERFORMANCE_DIAGNOSTICS__;
+	if (!sink) return null;
+	if (typeof sink === "function") return sink;
+	if (sink.enabled !== true && typeof sink.record !== "function") return null;
+	return sink;
+}
+function recordMinimapWorkerDiagnostic(sink, diagnostic) {
+	if (typeof sink === "function") {
+		sink(diagnostic);
+		return;
+	}
+	sink.record?.(diagnostic);
+}
+function minimapWorkerDiagnosticGlobal() {
+	return globalThis;
+}
+function nowMs() {
+	return globalThis.performance?.now() ?? Date.now();
+}
+//#endregion
+
+//# sourceMappingURL=minimap.worker-i4S59IOV.js.map