@singapore-editor/minimap 0.1.1

package/dist/workerClient.js

@@ -0,0 +1,1337 @@
+import { computeFrameLayout, computeRenderLayout, visibleDocumentLineRange } from "./layout.js";
+import { RGBA_BLACK, RGBA_WHITE, parseCssColor, transparent } from "./color.js";
+import { createError } from "@singapore-editor/core/logging/evlog";
+import { EditorSecondaryViewScheduler, createEditorSecondaryViewProjection } from "@singapore-editor/core/secondary-views";
+//#region src/workerClient.ts
+var MINIMAP_UPDATE_QUIET_DELAY_MS = 120;
+var MINIMAP_UPDATE_MAX_DELAY_MS = 300;
+var MINIMAP_FRAME_FLUSH_KEY = "minimap.flush.frame";
+var MINIMAP_QUIET_FLUSH_KEY = "minimap.flush.quiet";
+var MINIMAP_RENDER_KEY = "minimap.render";
+var MinimapWorkerOwner = class {
+	options;
+	worker = null;
+	lifecycle = "ready";
+	postedRequests = 0;
+	disposalAcknowledged = false;
+	lastError = null;
+	disposalPromise = null;
+	resolveDisposal = null;
+	rejectDisposal = null;
+	constructor(options) {
+		this.options = options;
+		this.worker = this.createWorker();
+	}
+	inspect() {
+		return {
+			lifecycle: this.lifecycle,
+			postedRequests: this.postedRequests,
+			disposalAcknowledged: this.disposalAcknowledged,
+			lastError: this.lastError?.message ?? null
+		};
+	}
+	post(request, transfer) {
+		const handle = this.worker;
+		if (!this.canPost(handle)) return false;
+		this.postedRequests += 1;
+		try {
+			this.postToWorker(handle, request, transfer);
+			return true;
+		} catch (error) {
+			this.fail(workerRequestError(error));
+			return false;
+		}
+	}
+	dispose() {
+		if (this.lifecycle === "disposed") return Promise.resolve();
+		if (this.disposalPromise) return this.disposalPromise;
+		if (!this.worker) {
+			this.finishDisposal();
+			return Promise.resolve();
+		}
+		this.lifecycle = "disposing";
+		this.disposalPromise = new Promise((resolve, reject) => {
+			this.resolveDisposal = resolve;
+			this.rejectDisposal = reject;
+		});
+		if (!this.post({ type: "dispose" })) this.rejectDisposal?.(this.lastError ?? workerDisposedError());
+		return this.disposalPromise;
+	}
+	createWorker() {
+		const handle = this.options.workerFactory?.() ?? new Worker(new URL("./assets/minimap.worker-i4S59IOV.js", import.meta.url), { type: "module" });
+		handle.onmessage = this.handleWorkerMessage;
+		handle.onerror = this.handleWorkerError;
+		return handle;
+	}
+	canPost(handle) {
+		if (!handle) return false;
+		if (this.lifecycle === "disposed") return false;
+		return this.lifecycle !== "crashed";
+	}
+	postToWorker(handle, request, transfer) {
+		if (transfer) {
+			handle.postMessage(request, transfer);
+			return;
+		}
+		handle.postMessage(request);
+	}
+	handleWorkerMessage = (event) => {
+		const response = event.data;
+		if (response.type === "disposed") {
+			this.disposalAcknowledged = true;
+			this.finishDisposal();
+			return;
+		}
+		if (response.type === "error") {
+			this.recordError(createWorkerResponseError(response));
+			return;
+		}
+		this.options.onMessage(response);
+	};
+	handleWorkerError = (event) => {
+		this.fail(createNativeWorkerError(event));
+	};
+	recordError(error) {
+		this.lastError = error;
+		this.options.onError?.(error);
+	}
+	fail(error) {
+		this.lastError = error;
+		this.lifecycle = "crashed";
+		this.terminateWorker();
+		this.rejectDisposal?.(error);
+		this.clearDisposalHandlers();
+		this.options.onError?.(error);
+	}
+	finishDisposal() {
+		this.lifecycle = "disposed";
+		this.terminateWorker();
+		this.resolveDisposal?.();
+		this.clearDisposalHandlers();
+	}
+	terminateWorker() {
+		this.worker?.terminate();
+		this.worker = null;
+	}
+	clearDisposalHandlers() {
+		this.resolveDisposal = null;
+		this.rejectDisposal = null;
+	}
+};
+var MinimapWorkerClient = class {
+	host;
+	options;
+	workerOwner;
+	colorResolver;
+	scheduler = new EditorSecondaryViewScheduler();
+	onLayoutWidth;
+	reservedLane;
+	externalDecorations;
+	pendingUpdate = null;
+	pendingUpdateReady = false;
+	pendingRender = false;
+	activeRenderToken = 0;
+	renderInFlight = false;
+	latestBaseStyles = null;
+	latestBaseStylesSignature = "";
+	latestLayoutSignature = "";
+	latestThemeSignature = "";
+	latestSnapshot;
+	latestViewport;
+	postedViewport = null;
+	latestFullDocumentSnapshot = null;
+	workerDocumentState = null;
+	latestTokenSource;
+	disposed = false;
+	constructor(options) {
+		this.host = options.host;
+		this.options = options.options;
+		this.onLayoutWidth = options.onLayoutWidth;
+		this.reservedLane = options.reservedLane;
+		this.externalDecorations = options.decorations;
+		this.latestSnapshot = options.snapshot;
+		this.latestViewport = options.snapshot.viewport;
+		this.latestTokenSource = options.snapshot.tokens;
+		this.colorResolver = new ColorResolver(options.host.colorScope);
+		this.workerOwner = new MinimapWorkerOwner({
+			onError: this.handleWorkerError,
+			onMessage: this.handleWorkerMessage
+		});
+		this.init(options.snapshot);
+	}
+	inspectWorker() {
+		return this.workerOwner.inspect();
+	}
+	update(snapshot, kind, change) {
+		if (this.disposed) return;
+		if (this.shouldSkipDocumentUpdate(snapshot, kind)) {
+			this.latestSnapshot = snapshot;
+			return;
+		}
+		const previousSnapshot = this.latestSnapshot;
+		this.latestSnapshot = snapshot;
+		if (kind === "viewport") {
+			this.latestViewport = snapshot.viewport;
+			const layoutUpdated = this.postLayoutIfNeeded(snapshot);
+			this.updateViewport(snapshot.viewport);
+			if (layoutUpdated) this.requestRender();
+			return;
+		}
+		const update = createPendingUpdate(snapshot, kind, change, previousSnapshot);
+		this.latestViewport = snapshot.viewport;
+		this.applyImmediateViewport();
+		this.queueUpdate(update);
+	}
+	queueUpdate(update) {
+		this.pendingUpdate = mergePendingUpdate(this.pendingUpdate, update);
+		recordMinimapPerformanceDiagnostic("minimap.updateClassification", () => pendingUpdateDiagnostics(update));
+		if (!this.renderInFlight) this.scheduleFlush();
+	}
+	updateViewport(viewport) {
+		if (this.disposed) return;
+		this.latestViewport = viewport;
+		this.applyImmediateViewport();
+		const next = this.viewport(this.latestSnapshot);
+		if (sameViewport(this.postedViewport, next)) return;
+		this.postedViewport = next;
+		this.post({
+			type: "updateViewport",
+			viewport: next
+		});
+		this.requestRender();
+	}
+	frameLayout() {
+		const viewport = this.viewport(this.latestSnapshot);
+		const metrics = this.metrics(this.latestSnapshot);
+		const renderLayout = computeRenderLayout({
+			minimap: this.options,
+			metrics,
+			viewport,
+			lineCount: this.latestSnapshot.lineCount
+		});
+		return computeFrameLayout({
+			renderLayout,
+			metrics,
+			viewport,
+			lineCount: this.latestSnapshot.lineCount,
+			realLineCount: this.latestSnapshot.lineCount,
+			previous: null
+		});
+	}
+	setExternalDecorations(decorations) {
+		if (this.disposed) return;
+		this.externalDecorations = decorations;
+		this.queueUpdate(createPendingUpdate(this.latestSnapshot, "decorations", null, this.latestSnapshot));
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.cancelScheduledFlush();
+		this.scheduler.dispose();
+		this.workerOwner.dispose().catch(() => void 0);
+		this.colorResolver.dispose();
+	}
+	init(snapshot) {
+		const mainCanvas = this.host.mainCanvas.transferControlToOffscreen();
+		const decorationsCanvas = this.host.decorationsCanvas.transferControlToOffscreen();
+		const baseStyles = this.baseStyles();
+		this.latestBaseStyles = baseStyles;
+		this.latestBaseStylesSignature = baseStylesSignature(baseStyles);
+		this.latestThemeSignature = themeSignature(snapshot);
+		const request = {
+			type: "init",
+			options: this.options,
+			baseStyles,
+			mainCanvas,
+			decorationsCanvas
+		};
+		this.post(request, [mainCanvas, decorationsCanvas]);
+		this.post({
+			type: "openDocument",
+			document: this.trackedDocumentPayload(snapshot)
+		});
+		this.latestFullDocumentSnapshot = snapshot;
+		this.postedViewport = this.viewport(snapshot);
+		this.post({
+			type: "updateLayout",
+			metrics: this.metrics(snapshot),
+			viewport: this.postedViewport
+		});
+		this.latestLayoutSignature = layoutSignature(snapshot, this.minimapHeight(snapshot));
+		this.postRender(snapshot);
+	}
+	scheduleFlush() {
+		const pending = this.pendingUpdate;
+		if (!pending) return;
+		if (this.pendingUpdateReady) {
+			this.scheduleFrameFlush();
+			return;
+		}
+		if (shouldDeferMinimapUpdate(pending)) {
+			this.scheduleDeferredFlush();
+			return;
+		}
+		this.scheduleFrameFlush();
+	}
+	scheduleFrameFlush() {
+		this.scheduler.schedule({
+			key: MINIMAP_FRAME_FLUSH_KEY,
+			taskClass: "visible-render",
+			priority: "high",
+			tags: {
+				configuration: "frame",
+				version: this.latestSnapshot.textVersion
+			},
+			run: () => this.flushPendingUpdate()
+		});
+	}
+	scheduleDeferredFlush() {
+		this.cancelScheduledFrame();
+		this.scheduler.schedule({
+			key: MINIMAP_QUIET_FLUSH_KEY,
+			taskClass: "background-derived",
+			priority: "low",
+			delayMs: MINIMAP_UPDATE_QUIET_DELAY_MS,
+			maxDelayMs: MINIMAP_UPDATE_MAX_DELAY_MS,
+			tags: {
+				configuration: "quiet",
+				version: this.latestSnapshot.textVersion
+			},
+			run: this.flushDeferredUpdate
+		});
+	}
+	flushDeferredUpdate = () => {
+		this.cancelDeferredFlush();
+		this.pendingUpdateReady = true;
+		this.scheduleFrameFlush();
+	};
+	flushPendingUpdate() {
+		if (this.disposed) return;
+		if (this.renderInFlight) return;
+		const pending = this.pendingUpdate;
+		if (!pending) return;
+		measureMinimapPerformance("minimap.flushPendingUpdate", () => this.flushPendingUpdateNow(pending), () => pendingUpdateDiagnostics(pending));
+	}
+	flushPendingUpdateNow(pending) {
+		this.pendingUpdate = null;
+		this.pendingUpdateReady = false;
+		measureMinimapPerformance("minimap.postUpdate", () => this.postUpdate(pending), () => pendingUpdateDiagnostics(pending));
+		const layoutUpdated = this.postLayoutIfNeeded(pending.snapshot);
+		this.postViewportIfNeeded(pending.snapshot, pending.syncViewport, layoutUpdated);
+		this.postRender(pending.snapshot);
+	}
+	postLayoutIfNeeded(snapshot) {
+		const signature = layoutSignature(snapshot, this.minimapHeight(snapshot));
+		if (signature === this.latestLayoutSignature) return false;
+		this.latestLayoutSignature = signature;
+		this.postedViewport = this.viewport(snapshot);
+		this.post({
+			type: "updateLayout",
+			metrics: this.metrics(snapshot),
+			viewport: this.postedViewport
+		});
+		return true;
+	}
+	postViewportIfNeeded(snapshot, syncViewport, layoutUpdated) {
+		if (layoutUpdated) return;
+		if (!syncViewport) return;
+		this.postedViewport = this.viewport(snapshot);
+		this.post({
+			type: "updateViewport",
+			viewport: this.postedViewport
+		});
+	}
+	postUpdate(update) {
+		const snapshot = update.snapshot;
+		let tokenColorsInvalidated = false;
+		if (update.syncBaseStyles) {
+			tokenColorsInvalidated = this.refreshThemeColorCache(snapshot);
+			tokenColorsInvalidated = this.syncBaseStyles() || tokenColorsInvalidated;
+		}
+		if (update.replaceDocument) {
+			this.post({
+				type: "replaceDocument",
+				document: this.trackedDocumentPayload(snapshot)
+			});
+			this.latestFullDocumentSnapshot = snapshot;
+			this.latestTokenSource = snapshot.tokens;
+			return;
+		}
+		if (update.edits.length > 0) {
+			this.latestFullDocumentSnapshot = null;
+			this.postEditUpdate(update);
+			this.latestTokenSource = update.tokenSourceAfterEdits;
+		}
+		if (update.syncTokens) this.postTokenUpdate(snapshot, tokenColorsInvalidated);
+		if (update.syncSelection && update.edits.length === 0) this.post({
+			type: "updateSelection",
+			selections: selections(snapshot.selections)
+		});
+		if (update.syncExternalDecorations) this.post({
+			type: "updateExternalDecorations",
+			decorations: this.externalDecorations
+		});
+	}
+	postEditUpdate(update) {
+		const document = this.documentEditPayload(update, this.workerDocumentState);
+		const patch = document.summaryPatch;
+		if (this.workerDocumentState) this.workerDocumentState = {
+			textLength: patch.textLength,
+			lineCount: this.workerDocumentState.lineCount - patch.deleteCount + patch.lines.length
+		};
+		if (update.edits.length === 1) {
+			this.post({
+				type: "applyEdit",
+				edit: update.edits[0],
+				document
+			});
+			return;
+		}
+		this.post({
+			type: "applyEdits",
+			edits: update.edits,
+			document
+		});
+	}
+	trackedDocumentPayload(snapshot) {
+		const document = this.documentPayload(snapshot);
+		this.workerDocumentState = {
+			textLength: document.textLength,
+			lineCount: document.lines.length
+		};
+		return document;
+	}
+	postTokenUpdate(snapshot, forceFullUpdate) {
+		const sourceTokens = this.latestTokenSource;
+		if (forceFullUpdate || !sourceTokens) {
+			this.postFullTokenUpdate(snapshot);
+			return;
+		}
+		const patch = this.tokenPatch(sourceTokens, snapshot.tokens);
+		this.latestTokenSource = snapshot.tokens;
+		if (patch.deleteCount === 0 && patch.tokens.length === 0) return;
+		this.post({
+			type: "updateTokenRange",
+			patch
+		});
+	}
+	postFullTokenUpdate(snapshot) {
+		this.post({
+			type: "updateTokens",
+			tokens: this.tokens(snapshot.tokens)
+		});
+		this.latestTokenSource = snapshot.tokens;
+	}
+	tokenPatch(previous, next) {
+		const range = previous.changedRangeTo(next);
+		return {
+			start: range.start,
+			deleteCount: range.deleteCount,
+			tokens: this.tokens(next, range.start, range.insertEnd)
+		};
+	}
+	syncBaseStyles() {
+		const styles = this.baseStyles();
+		const signature = baseStylesSignature(styles);
+		if (signature === this.latestBaseStylesSignature) return false;
+		this.latestBaseStyles = styles;
+		this.latestBaseStylesSignature = signature;
+		this.colorResolver.clear();
+		this.post({
+			type: "updateBaseStyles",
+			baseStyles: styles
+		});
+		return true;
+	}
+	refreshThemeColorCache(snapshot) {
+		const signature = themeSignature(snapshot);
+		if (signature === this.latestThemeSignature) return false;
+		this.latestThemeSignature = signature;
+		this.colorResolver.clear();
+		return true;
+	}
+	shouldSkipDocumentUpdate(snapshot, kind) {
+		if (kind !== "document") return false;
+		const latest = this.latestFullDocumentSnapshot;
+		if (!latest) return false;
+		return latest === snapshot;
+	}
+	requestRender() {
+		if (this.renderInFlight) {
+			this.pendingRender = true;
+			return;
+		}
+		this.postRender(this.latestSnapshot);
+	}
+	postRender(snapshot) {
+		this.pendingRender = false;
+		let renderToken = 0;
+		const handle = this.scheduler.schedule({
+			key: MINIMAP_RENDER_KEY,
+			taskClass: "visible-render",
+			priority: "high",
+			defer: true,
+			tags: {
+				configuration: "render",
+				snapshotVersion: snapshot.textVersion,
+				viewport: snapshot.viewport.visibleRange.start
+			},
+			run: (context) => this.postScheduledRender(snapshot, context.token),
+			cancel: () => this.cancelScheduledRender(renderToken)
+		});
+		renderToken = handle.token;
+		this.activeRenderToken = handle.token;
+		this.renderInFlight = true;
+	}
+	postScheduledRender(snapshot, token) {
+		if (token !== this.activeRenderToken) return;
+		this.pendingRender = false;
+		this.sizeCanvasElements(snapshot);
+		this.post({
+			type: "render",
+			sequence: token
+		});
+	}
+	cancelScheduledRender(token) {
+		if (token !== this.activeRenderToken) return;
+		this.activeRenderToken = 0;
+		this.renderInFlight = false;
+	}
+	applyImmediateViewport() {
+		const frame = this.frameLayout();
+		setStyleValue(this.host.slider, "display", frame.sliderNeeded ? "block" : "none");
+		setStyleValue(this.host.slider, "transform", `translate3d(0, ${frame.sliderTop}px, 0)`);
+		setStyleValue(this.host.slider, "height", `${frame.sliderHeight}px`);
+		setStyleValue(this.host.sliderHorizontal, "height", `${frame.sliderHeight}px`);
+		setClassName(this.host.shadow, shadowVisible(this.latestViewport) ? "editor-minimap-shadow editor-minimap-shadow-visible" : "editor-minimap-shadow editor-minimap-shadow-hidden");
+	}
+	documentPayload(snapshot) {
+		const projection = createEditorSecondaryViewProjection(snapshot);
+		let payload = null;
+		return measureMinimapPerformance("minimap.documentPayload", () => {
+			payload = {
+				...documentSummaryPayload(projection.text, this.options.maxColumn),
+				tokens: this.tokens(projection.syntaxColors.tokens),
+				selections: selections(projection.selections),
+				decorations: this.externalDecorations,
+				externalDecorations: this.externalDecorations
+			};
+			return payload;
+		}, () => documentPayloadDiagnostics(payload));
+	}
+	documentEditPayload(update, workerDocument) {
+		const snapshot = update.snapshot;
+		const projection = createEditorSecondaryViewProjection(snapshot);
+		let payload = null;
+		return measureMinimapPerformance("minimap.documentEditPayload", () => {
+			payload = {
+				selections: selections(projection.selections),
+				summaryPatch: documentSummaryPatchPayload(projection.text, previousDocumentSummary(update), update.edits, this.options.maxColumn, workerDocument)
+			};
+			return payload;
+		}, () => documentEditPayloadDiagnostics(payload));
+	}
+	tokens(tokens, from = 0, to = tokens.length) {
+		return measureMinimapPerformance("minimap.tokens", () => {
+			const foreground = this.latestBaseStyles?.foreground ?? this.baseStyles().foreground;
+			const colors = tokens.styles.map((style) => this.colorResolver.resolve(style.color, foreground));
+			const projected = [];
+			tokens.forEachInRange(from, to, (start, end, styleId) => {
+				projected.push({
+					start,
+					end,
+					color: colors[styleId]
+				});
+			});
+			return projected;
+		}, () => ({
+			inputTokens: tokens.length,
+			outputTokens: Math.max(0, to - from)
+		}));
+	}
+	metrics(snapshot) {
+		return {
+			rowHeight: snapshot.metrics.rowHeight,
+			characterWidth: snapshot.metrics.characterWidth,
+			devicePixelRatio: globalThis.devicePixelRatio || 1
+		};
+	}
+	viewport(snapshot) {
+		const snapshotViewport = this.latestViewport;
+		const fallbackClientHeight = snapshotViewport.clientHeight > 0 ? 0 : this.host.colorScope.clientHeight;
+		const fallbackClientWidth = snapshotViewport.clientWidth > 0 ? 0 : Math.max(0, this.host.colorScope.clientWidth - this.reservedLane());
+		const clientHeight = positiveOrFallback(snapshotViewport.clientHeight, fallbackClientHeight);
+		const clientWidth = positiveOrFallback(snapshotViewport.clientWidth, fallbackClientWidth);
+		const fallbackScrollHeight = snapshotViewport.scrollHeight > 0 ? 0 : this.host.colorScope.scrollHeight;
+		const fallbackScrollWidth = snapshotViewport.scrollWidth > 0 ? 0 : this.host.colorScope.scrollWidth;
+		const range = visibleDocumentLineRange(snapshot, snapshotViewport);
+		return {
+			scrollTop: snapshotViewport.scrollTop,
+			scrollRow: snapshotViewport.scrollRow,
+			scrollLeft: snapshotViewport.scrollLeft,
+			scrollHeight: Math.max(snapshotViewport.scrollHeight, fallbackScrollHeight, clientHeight),
+			scrollWidth: Math.max(snapshotViewport.scrollWidth, fallbackScrollWidth, clientWidth),
+			clientHeight,
+			clientWidth,
+			minimapHeight: this.minimapHeight(snapshot),
+			reservedWidth: Math.max(0, this.reservedLane()),
+			visibleStart: range.start,
+			visibleEnd: range.end
+		};
+	}
+	minimapHeight(snapshot) {
+		const height = Number.parseFloat(this.host.root.style.height);
+		if (Number.isFinite(height)) return Math.max(0, height);
+		if (snapshot.viewport.clientHeight > 0) return snapshot.viewport.clientHeight;
+		return this.host.colorScope.clientHeight;
+	}
+	baseStyles() {
+		const style = getComputedStyle(this.host.colorScope);
+		const foreground = this.colorResolver.resolve(style.color, RGBA_WHITE);
+		const background = this.colorResolver.resolve(style.backgroundColor, RGBA_BLACK);
+		return {
+			foreground,
+			background,
+			minimapBackground: transparent(this.colorResolver.resolve(style.getPropertyValue("--editor-minimap-background"), background), minimapBackgroundOpacity(style)),
+			foregroundOpacity: 255,
+			selection: this.colorResolver.resolve(style.getPropertyValue("--editor-minimap-selection-highlight"), {
+				r: 56,
+				g: 189,
+				b: 248,
+				a: 128
+			}),
+			slider: style.getPropertyValue("--editor-minimap-slider-background") || "rgba(121,121,121,.2)",
+			sliderHover: style.getPropertyValue("--editor-minimap-slider-hover-background") || "rgba(121,121,121,.35)",
+			sliderActive: style.getPropertyValue("--editor-minimap-slider-active-background") || "rgba(121,121,121,.5)",
+			fontFamily: style.fontFamily || "monospace"
+		};
+	}
+	sizeCanvasElements(snapshot) {
+		const height = `${this.minimapHeight(snapshot)}px`;
+		setStyleValue(this.host.mainCanvas, "height", height);
+		setStyleValue(this.host.decorationsCanvas, "height", height);
+	}
+	handleWorkerMessage = (response) => {
+		if (this.disposed) return;
+		if (response.type === "layout") {
+			this.applyLayout(response.layout.width, response.layout.canvasOuterWidth, response.layout.canvasOuterHeight);
+			return;
+		}
+		if (response.type === "rendered") {
+			if (!this.isCurrentRenderResponse(response)) return;
+			this.scheduler.cancel(MINIMAP_RENDER_KEY);
+			this.renderInFlight = false;
+			this.activeRenderToken = 0;
+			if (this.pendingUpdate) this.scheduleFlush();
+			if (this.renderInFlight) return;
+			if (this.pendingRender) this.requestRender();
+			this.applyImmediateViewport();
+			return;
+		}
+	};
+	applyLayout(width, canvasWidth, canvasHeight) {
+		this.onLayoutWidth(width);
+		setStyleValue(this.host.mainCanvas, "width", `${canvasWidth}px`);
+		setStyleValue(this.host.decorationsCanvas, "width", `${canvasWidth}px`);
+		setStyleValue(this.host.sliderHorizontal, "width", `${canvasWidth}px`);
+		setStyleValue(this.host.mainCanvas, "height", `${canvasHeight}px`);
+		setStyleValue(this.host.decorationsCanvas, "height", `${canvasHeight}px`);
+	}
+	handleWorkerError = (error) => {
+		console.warn(error.toString(), error);
+	};
+	post(request, transfer) {
+		measureMinimapPerformance("minimap.post", () => {
+			this.workerOwner.post(request, transfer);
+		}, () => requestDiagnostics(request));
+	}
+	cancelScheduledFlush() {
+		this.cancelScheduledFrame();
+		this.cancelDeferredFlush();
+	}
+	cancelScheduledFrame() {
+		this.scheduler.cancel(MINIMAP_FRAME_FLUSH_KEY);
+	}
+	cancelDeferredFlush() {
+		this.scheduler.cancel(MINIMAP_QUIET_FLUSH_KEY);
+	}
+	isCurrentRenderResponse(response) {
+		return response.sequence === this.activeRenderToken;
+	}
+};
+function canUseMinimapWorker() {
+	if (typeof Worker === "undefined") return false;
+	if (typeof OffscreenCanvas === "undefined") return false;
+	return typeof HTMLCanvasElement !== "undefined" && "transferControlToOffscreen" in HTMLCanvasElement.prototype;
+}
+function workerRequestError(error) {
+	if (error instanceof Error) return error;
+	return new Error(String(error));
+}
+function createWorkerResponseError(response) {
+	const workerMessage = nonEmptyString(response.message);
+	return createError({
+		code: "minimap.WORKER_REQUEST_FAILED",
+		message: messageWithDetail("Minimap worker request failed", workerMessage),
+		why: workerMessage ?? "The minimap worker reported an error without details.",
+		fix: "The editor keeps running; inspect the minimap worker request and renderer state if the minimap stops updating.",
+		internal: {
+			responseType: response.type,
+			sequence: response.sequence ?? null,
+			workerMessage: response.message
+		}
+	});
+}
+function createNativeWorkerError(event) {
+	const browserMessage = nonEmptyString(event.message);
+	return createError({
+		code: "minimap.WORKER_CRASHED",
+		message: messageWithDetail("Minimap worker crashed", browserMessage),
+		why: nativeWorkerFailureReason(browserMessage),
+		fix: "The editor keeps running without the minimap for this worker generation. Check the worker script request, CSP, MIME type, and browser worker support.",
+		cause: event.error instanceof Error ? event.error : void 0,
+		internal: workerErrorEventInternal(event)
+	});
+}
+function nativeWorkerFailureReason(browserMessage) {
+	if (browserMessage) return `The browser reported: ${browserMessage}`;
+	return "The browser reported a native worker failure without an error message. This usually means the worker script failed to load or crashed before its own error handler ran.";
+}
+function workerErrorEventInternal(event) {
+	const error = event.error;
+	return {
+		browserMessage: nonEmptyString(event.message),
+		filename: nonEmptyString(event.filename),
+		lineNumber: positiveNumberOrNull(event.lineno),
+		columnNumber: positiveNumberOrNull(event.colno),
+		errorName: error instanceof Error ? error.name : null,
+		errorMessage: errorMessage(error),
+		errorStack: error instanceof Error ? error.stack : null,
+		rawErrorType: rawErrorType(error)
+	};
+}
+function errorMessage(error) {
+	if (error instanceof Error) return error.message;
+	if (typeof error === "string") return error;
+	return null;
+}
+function rawErrorType(error) {
+	if (error === null || error === void 0) return null;
+	if (error instanceof Error) return error.name;
+	return Object.prototype.toString.call(error);
+}
+function messageWithDetail(summary, detail) {
+	if (!detail) return summary;
+	return `${summary}: ${detail}`;
+}
+function nonEmptyString(value) {
+	const trimmed = value?.trim() ?? "";
+	if (trimmed.length === 0) return null;
+	return trimmed;
+}
+function positiveNumberOrNull(value) {
+	if (value > 0) return value;
+	return null;
+}
+function workerDisposedError() {
+	return /* @__PURE__ */ new Error("Minimap worker is disposed");
+}
+function selections(selections) {
+	return selections.map((selection) => minimapSelection(selection));
+}
+function minimapSelection(selection) {
+	return {
+		startOffset: selection.startOffset,
+		endOffset: selection.endOffset
+	};
+}
+function arrayLineStarts(lineStarts) {
+	return {
+		length: lineStarts.length,
+		at: (index) => lineStarts[index],
+		indexForOffset: (offset) => arrayLineIndexForOffset(lineStarts, offset),
+		firstIndexAtOrAfter: (target) => arrayFirstLineStartAtOrAfter(lineStarts, target),
+		toArray: () => lineStarts
+	};
+}
+function documentSummaryPayload(text, maxColumn) {
+	const textLength = text.length;
+	const lineStarts = text.lineStartsView.toArray();
+	return {
+		textLength,
+		lineStarts,
+		lines: lineStarts.map((startOffset, index) => lineSummaryFromSnapshot(text, startOffset, lineEndOffset(arrayLineStarts(lineStarts), index, textLength), maxColumn))
+	};
+}
+function documentSummaryPatchPayload(text, previous, edits, maxColumn, workerDocument) {
+	const textLength = text.length;
+	const lineStarts = text.lineStartsView;
+	const range = documentSummaryPatchRange(previous, lineStarts, textLength, edits, workerDocument);
+	const lines = [];
+	for (let lineIndex = range.startLine; lineIndex < range.insertEndLine; lineIndex += 1) lines.push(lineSummaryFromSnapshot(text, lineStarts.at(lineIndex) ?? textLength, lineEndOffset(lineStarts, lineIndex, textLength), maxColumn));
+	return {
+		textLength,
+		startLine: range.startLine,
+		deleteCount: range.deleteCount,
+		lines
+	};
+}
+function lineSummaryFromSnapshot(text, startOffset, endOffset, maxColumn) {
+	const length = Math.max(0, endOffset - startOffset);
+	const clippedEnd = startOffset + Math.min(length, maxColumn);
+	return {
+		text: text.snapshot.readRange(startOffset, clippedEnd),
+		length
+	};
+}
+function lineEndOffset(lineStarts, index, textLength) {
+	const startOffset = lineStarts.at(index) ?? textLength;
+	const nextStart = lineStarts.at(index + 1);
+	if (nextStart === void 0) return textLength;
+	return Math.max(startOffset, nextStart - 1);
+}
+function documentSummaryPatchRange(previous, nextLineStarts, nextTextLength, edits, workerDocument) {
+	const edited = editSummaryPatchRange(previous.lineStarts, nextLineStarts, edits);
+	if (edited && workerDocument && editsExplainTransition(workerDocument, nextLineStarts, nextTextLength, edits)) return normalizeSummaryPatchRange(edited, previous.lineStarts.length, nextLineStarts.length);
+	const changed = mergeSummaryPatchRanges(lineStartSummaryPatchRange(previous.lineStarts, previous.textLength, nextLineStarts, nextTextLength), edited);
+	if (!changed) return {
+		startLine: 0,
+		deleteCount: 0,
+		insertEndLine: 0
+	};
+	return normalizeSummaryPatchRange(changed, previous.lineStarts.length, nextLineStarts.length);
+}
+function editsExplainTransition(workerDocument, nextLineStarts, nextTextLength, edits) {
+	if (nextLineStarts.length !== workerDocument.lineCount) return false;
+	let textDelta = 0;
+	for (const edit of edits) {
+		if (edit.text.includes("\n")) return false;
+		textDelta += edit.text.length - (Math.max(edit.from, edit.to) - Math.min(edit.from, edit.to));
+	}
+	return workerDocument.textLength + textDelta === nextTextLength;
+}
+function arrayFirstLineStartAtOrAfter(lineStarts, target) {
+	let low = 0;
+	let high = lineStarts.length;
+	while (low < high) {
+		const middle = low + high >> 1;
+		if (lineStarts[middle] < target) low = middle + 1;
+		else high = middle;
+	}
+	return low;
+}
+function lineStartSummaryPatchRange(previousLineStarts, previousTextLength, nextLineStarts, nextTextLength) {
+	const prefix = commonLineSummaryPrefix(previousLineStarts, previousTextLength, nextLineStarts, nextTextLength);
+	const suffix = commonLineSummarySuffix(previousLineStarts, previousTextLength, nextLineStarts, nextTextLength, prefix);
+	if (prefix + suffix >= previousLineStarts.length && prefix + suffix >= nextLineStarts.length) return null;
+	return {
+		startLine: prefix,
+		previousEndLine: previousLineStarts.length - suffix,
+		nextEndLine: nextLineStarts.length - suffix
+	};
+}
+function commonLineSummaryPrefix(previousLineStarts, previousTextLength, nextLineStarts, nextTextLength) {
+	let count = 0;
+	const limit = Math.min(previousLineStarts.length, nextLineStarts.length);
+	while (count < limit && lineSummaryBoundariesMatch(previousLineStarts, previousTextLength, count, nextLineStarts, nextTextLength, count, 0)) count += 1;
+	return count;
+}
+function commonLineSummarySuffix(previousLineStarts, previousTextLength, nextLineStarts, nextTextLength, prefix) {
+	let count = 0;
+	const delta = nextTextLength - previousTextLength;
+	const previousLimit = previousLineStarts.length - prefix;
+	const nextLimit = nextLineStarts.length - prefix;
+	while (count < previousLimit && count < nextLimit) {
+		if (!lineSummaryBoundariesMatch(previousLineStarts, previousTextLength, previousLineStarts.length - count - 1, nextLineStarts, nextTextLength, nextLineStarts.length - count - 1, delta)) return count;
+		count += 1;
+	}
+	return count;
+}
+function lineSummaryBoundariesMatch(previousLineStarts, previousTextLength, previousIndex, nextLineStarts, nextTextLength, nextIndex, offsetDelta) {
+	const previousStart = previousLineStarts.at(previousIndex) ?? previousTextLength;
+	const nextStart = nextLineStarts.at(nextIndex) ?? nextTextLength;
+	if (previousStart + offsetDelta !== nextStart) return false;
+	return lineEndOffset(previousLineStarts, previousIndex, previousTextLength) + offsetDelta === lineEndOffset(nextLineStarts, nextIndex, nextTextLength);
+}
+function editSummaryPatchRange(previousLineStarts, nextLineStarts, edits) {
+	let startLine = Number.POSITIVE_INFINITY;
+	let previousEndLine = 0;
+	let nextEndLine = 0;
+	for (const edit of edits) {
+		if (editIsEmpty(edit)) continue;
+		const previousRange = previousLineRangeForEdit(previousLineStarts, nextLineStarts, edit);
+		const nextRange = lineRangeForEdit(nextLineStarts, edit.from, edit.from + edit.text.length);
+		startLine = Math.min(startLine, previousRange.startLine, nextRange.startLine);
+		previousEndLine = Math.max(previousEndLine, previousRange.endLine);
+		nextEndLine = Math.max(nextEndLine, nextRange.endLine);
+	}
+	if (startLine === Number.POSITIVE_INFINITY) return null;
+	return {
+		startLine,
+		previousEndLine,
+		nextEndLine
+	};
+}
+function editIsEmpty(edit) {
+	return edit.from === edit.to && edit.text.length === 0;
+}
+function previousLineRangeForEdit(previousLineStarts, nextLineStarts, edit) {
+	if (edit.from !== edit.to || edit.text.includes("\n")) return lineRangeForEdit(previousLineStarts, edit.from, edit.to);
+	const line = nextLineStarts.indexForOffset(edit.from);
+	return {
+		startLine: line,
+		endLine: line + 1
+	};
+}
+function lineRangeForEdit(lineStarts, from, to) {
+	const startOffset = Math.min(from, to);
+	const endOffset = Math.max(from, to);
+	return {
+		startLine: lineStarts.indexForOffset(startOffset),
+		endLine: lineStarts.indexForOffset(endOffset) + 1
+	};
+}
+function mergeSummaryPatchRanges(left, right) {
+	if (!left) return right;
+	if (!right) return left;
+	return {
+		startLine: Math.min(left.startLine, right.startLine),
+		previousEndLine: Math.max(left.previousEndLine, right.previousEndLine),
+		nextEndLine: Math.max(left.nextEndLine, right.nextEndLine)
+	};
+}
+function normalizeSummaryPatchRange(range, previousLineCount, nextLineCount) {
+	const startLine = Math.min(Math.max(0, range.startLine), Math.max(previousLineCount, nextLineCount));
+	const previousEndLine = Math.min(Math.max(startLine, range.previousEndLine), previousLineCount);
+	const nextEndLine = Math.min(Math.max(startLine, range.nextEndLine), nextLineCount);
+	return {
+		startLine,
+		deleteCount: previousEndLine - startLine,
+		insertEndLine: nextEndLine
+	};
+}
+function incrementalTextEdits(change) {
+	if (!change || change.edits.length === 0) return null;
+	return sequentialTextEdits(change.edits.toSorted(compareTextEdits));
+}
+function sameViewport(previous, next) {
+	if (!previous) return false;
+	return previous.scrollTop === next.scrollTop && previous.scrollRow === next.scrollRow && previous.scrollLeft === next.scrollLeft && previous.scrollHeight === next.scrollHeight && previous.scrollWidth === next.scrollWidth && previous.clientHeight === next.clientHeight && previous.clientWidth === next.clientWidth && previous.minimapHeight === next.minimapHeight && previous.reservedWidth === next.reservedWidth && previous.visibleStart === next.visibleStart && previous.visibleEnd === next.visibleEnd;
+}
+function shadowVisible(viewport) {
+	return viewport.scrollLeft + viewport.clientWidth < viewport.scrollWidth;
+}
+function positiveOrFallback(value, fallback) {
+	if (value > 0) return value;
+	return Math.max(0, fallback);
+}
+function baseStylesSignature(styles) {
+	return JSON.stringify(styles);
+}
+function layoutSignature(snapshot, minimapHeight) {
+	return [
+		snapshot.metrics.rowHeight,
+		snapshot.metrics.characterWidth,
+		globalThis.devicePixelRatio || 1,
+		snapshot.viewport.clientHeight,
+		snapshot.viewport.clientWidth,
+		minimapHeight,
+		snapshot.lineCount
+	].join(":");
+}
+function createPendingUpdate(snapshot, kind, change, previousSnapshot) {
+	const base = basePendingUpdate(snapshot, kind);
+	if (kind === "content") return contentPendingUpdate(base, change, previousSnapshot);
+	if (kind === "document" || kind === "clear") return {
+		...base,
+		replaceDocument: true,
+		reason: kind
+	};
+	if (kind === "tokens") return {
+		...base,
+		syncTokens: true,
+		reason: "tokens"
+	};
+	if (kind === "selection") return {
+		...base,
+		syncSelection: true,
+		reason: "selection"
+	};
+	if (kind === "decorations") return {
+		...base,
+		syncExternalDecorations: true,
+		reason: "decorations"
+	};
+	return {
+		...base,
+		reason: kind
+	};
+}
+function mergePendingUpdate(current, next) {
+	if (!current) return next;
+	if (current.replaceDocument || next.replaceDocument) return mergeReplacementUpdate(current, next);
+	const edits = current.edits.concat(next.edits);
+	const contentChangedAfterTokens = next.edits.length > 0;
+	return {
+		snapshot: next.snapshot,
+		replaceDocument: false,
+		edits,
+		previousDocumentSummary: current.previousDocumentSummary ?? next.previousDocumentSummary,
+		syncTokens: contentChangedAfterTokens ? next.syncTokens : current.syncTokens || next.syncTokens,
+		syncSelection: current.syncSelection || next.syncSelection,
+		syncExternalDecorations: current.syncExternalDecorations || next.syncExternalDecorations,
+		syncViewport: current.syncViewport || next.syncViewport,
+		syncBaseStyles: current.syncBaseStyles || next.syncBaseStyles,
+		tokenSourceAfterEdits: mergedTokenSourceAfterEdits(current, next),
+		reason: mergeReasons(current.reason, next.reason)
+	};
+}
+function mergeReplacementUpdate(current, next) {
+	return {
+		snapshot: next.snapshot,
+		replaceDocument: true,
+		edits: [],
+		previousDocumentSummary: null,
+		syncTokens: false,
+		syncSelection: false,
+		syncExternalDecorations: false,
+		syncViewport: current.syncViewport || next.syncViewport,
+		syncBaseStyles: current.syncBaseStyles || next.syncBaseStyles,
+		tokenSourceAfterEdits: null,
+		reason: mergeReasons(current.reason, next.reason)
+	};
+}
+function mergedTokenSourceAfterEdits(current, next) {
+	if (next.edits.length === 0) return current.tokenSourceAfterEdits;
+	if (current.syncTokens) return null;
+	return next.tokenSourceAfterEdits;
+}
+function shouldSyncBaseStyles(kind) {
+	if (kind === "tokens") return true;
+	if (kind === "document") return true;
+	return kind === "clear";
+}
+function basePendingUpdate(snapshot, kind) {
+	return {
+		snapshot,
+		replaceDocument: false,
+		edits: [],
+		previousDocumentSummary: null,
+		syncTokens: false,
+		syncSelection: false,
+		syncExternalDecorations: false,
+		syncViewport: shouldSyncViewport(kind),
+		syncBaseStyles: shouldSyncBaseStyles(kind),
+		tokenSourceAfterEdits: null,
+		reason: "metadata"
+	};
+}
+function contentPendingUpdate(base, change, previousSnapshot) {
+	const edits = incrementalTextEdits(change);
+	if (!edits) return {
+		...base,
+		replaceDocument: true,
+		reason: "content.replaceDocument"
+	};
+	return {
+		...base,
+		edits,
+		previousDocumentSummary: snapshotSummaryBaseline(previousSnapshot),
+		syncSelection: true,
+		tokenSourceAfterEdits: tokenSourceAfterEdits(change, previousSnapshot, base.snapshot),
+		reason: edits.length === 1 ? "content.edit" : "content.edits"
+	};
+}
+function previousDocumentSummary(update) {
+	return update.previousDocumentSummary ?? snapshotSummaryBaseline(update.snapshot);
+}
+function snapshotSummaryBaseline(snapshot) {
+	return {
+		textLength: snapshot.textSnapshot.length,
+		lineStarts: snapshot.lineStartsView
+	};
+}
+function shouldSyncViewport(kind) {
+	if (kind === "content") return true;
+	if (kind === "document") return true;
+	if (kind === "clear") return true;
+	if (kind === "viewport") return true;
+	return kind === "layout";
+}
+function shouldDeferMinimapUpdate(update) {
+	if (update.reason.includes("content")) return true;
+	if (update.syncTokens) return true;
+	return update.syncExternalDecorations;
+}
+function sequentialTextEdits(edits) {
+	let delta = 0;
+	return edits.map((edit) => {
+		const from = edit.from + delta;
+		const to = edit.to + delta;
+		delta += edit.text.length - (edit.to - edit.from);
+		return {
+			from,
+			to,
+			text: edit.text
+		};
+	});
+}
+function compareTextEdits(left, right) {
+	return left.from - right.from || left.to - right.to;
+}
+function tokenSourceAfterEdits(change, previousSnapshot, nextSnapshot) {
+	if (!change) return null;
+	if (!editsPreserveLineStructure(change.edits, previousSnapshot.lineStartsView)) return null;
+	return nextSnapshot.tokens;
+}
+function editsPreserveLineStructure(edits, lineStarts) {
+	for (const edit of edits) {
+		if (edit.text.includes("\n")) return false;
+		if (!editRangeIsSingleLine(lineStarts, edit)) return false;
+	}
+	return true;
+}
+function editRangeIsSingleLine(lineStarts, edit) {
+	return lineStarts.indexForOffset(edit.from) === lineStarts.indexForOffset(edit.to);
+}
+function arrayLineIndexForOffset(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);
+}
+function mergeReasons(left, right) {
+	if (left === right) return left;
+	return `${left}+${right}`;
+}
+function measureMinimapPerformance(name, run, detail) {
+	if (!minimapPerformanceDiagnosticsEnabled()) return run();
+	const start = nowMs();
+	try {
+		return run();
+	} finally {
+		recordMinimapPerformanceDiagnostic(name, detail, nowMs() - start);
+	}
+}
+function recordMinimapPerformanceDiagnostic(name, detail, durationMs) {
+	const sink = minimapPerformanceDiagnosticSink();
+	if (!sink) return;
+	const diagnostic = createDiagnostic(name, detail, durationMs);
+	if (typeof sink === "function") {
+		sink(diagnostic);
+		return;
+	}
+	sink.record?.(diagnostic);
+}
+function minimapPerformanceDiagnosticsEnabled() {
+	const sink = minimapPerformanceDiagnosticGlobal().__EDITOR_PERFORMANCE_DIAGNOSTICS__;
+	if (!sink) return false;
+	if (typeof sink === "function") return true;
+	return sink.enabled === true || typeof sink.record === "function";
+}
+function minimapPerformanceDiagnosticSink() {
+	const sink = minimapPerformanceDiagnosticGlobal().__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 createDiagnostic(name, detail, durationMs) {
+	const resolvedDetail = resolveDiagnosticDetail(detail);
+	if (durationMs === void 0 && resolvedDetail === void 0) return { name };
+	if (durationMs === void 0) return {
+		name,
+		detail: resolvedDetail
+	};
+	if (resolvedDetail === void 0) return {
+		name,
+		durationMs
+	};
+	return {
+		name,
+		durationMs,
+		detail: resolvedDetail
+	};
+}
+function resolveDiagnosticDetail(detail) {
+	if (typeof detail === "function") return detail();
+	return detail;
+}
+function minimapPerformanceDiagnosticGlobal() {
+	return globalThis;
+}
+function pendingUpdateDiagnostics(update) {
+	return {
+		editCount: update.edits.length,
+		incremental: !update.replaceDocument,
+		reason: update.reason,
+		syncBaseStyles: update.syncBaseStyles,
+		syncExternalDecorations: update.syncExternalDecorations,
+		syncSelection: update.syncSelection,
+		syncTokens: update.syncTokens,
+		syncViewport: update.syncViewport,
+		tokenSourceKnown: update.tokenSourceAfterEdits !== null || update.edits.length === 0,
+		type: update.replaceDocument ? "replaceDocument" : "incremental"
+	};
+}
+function requestDiagnostics(request) {
+	switch (request.type) {
+		case "openDocument":
+		case "replaceDocument": return {
+			request: request.type,
+			...documentPayloadDiagnostics(request.document)
+		};
+		case "applyEdit": return {
+			request: request.type,
+			editTextLength: request.edit.text.length,
+			...documentEditPayloadDiagnostics(request.document)
+		};
+		case "applyEdits": return {
+			request: request.type,
+			editCount: request.edits.length,
+			editTextLength: textLengthForEdits(request.edits),
+			...documentEditPayloadDiagnostics(request.document)
+		};
+		case "updateTokens": return {
+			request: request.type,
+			tokens: request.tokens.length
+		};
+		case "updateTokenRange": return {
+			request: request.type,
+			deleteCount: request.patch.deleteCount,
+			start: request.patch.start,
+			tokens: request.patch.tokens.length
+		};
+		case "updateSelection": return {
+			request: request.type,
+			selections: request.selections.length
+		};
+		case "updateDecorations":
+		case "updateExternalDecorations": return {
+			request: request.type,
+			decorations: request.decorations.length
+		};
+		default: return { request: "control" };
+	}
+}
+function documentPayloadDiagnostics(payload) {
+	return {
+		decorations: payload?.decorations.length ?? 0,
+		externalDecorations: payload?.externalDecorations?.length ?? 0,
+		lineSummaryTextLength: lineSummaryTextLength(payload?.lines ?? []),
+		lineStarts: payload?.lineStarts.length ?? 0,
+		lines: payload?.lines.length ?? 0,
+		selections: payload?.selections.length ?? 0,
+		textLength: payload?.textLength ?? 0,
+		tokens: payload?.tokens.length ?? 0,
+		type: "document"
+	};
+}
+function documentEditPayloadDiagnostics(payload) {
+	const patch = payload?.summaryPatch;
+	return {
+		deleteCount: patch?.deleteCount ?? 0,
+		lineSummaryTextLength: lineSummaryTextLength(patch?.lines ?? []),
+		lineStarts: patch?.lineStarts?.length ?? 0,
+		lines: patch?.lines.length ?? 0,
+		selections: payload?.selections.length ?? 0,
+		startLine: patch?.startLine ?? 0,
+		textLength: patch?.textLength ?? 0,
+		type: "edit"
+	};
+}
+function lineSummaryTextLength(lines) {
+	let length = 0;
+	for (const line of lines) length += line.text.length;
+	return length;
+}
+function textLengthForEdits(edits) {
+	let length = 0;
+	for (const edit of edits) length += edit.text.length;
+	return length;
+}
+function setStyleValue(element, property, value) {
+	if (element.style[property] === value) return;
+	element.style[property] = value;
+}
+function setClassName(element, className) {
+	if (element.className === className) return;
+	element.className = className;
+}
+function minimapBackgroundOpacity(style) {
+	const value = Number.parseFloat(style.getPropertyValue("--editor-minimap-background-opacity"));
+	if (!Number.isFinite(value)) return 1;
+	return Math.min(1, Math.max(0, value));
+}
+function themeSignature(snapshot) {
+	return JSON.stringify(snapshot.theme ?? null);
+}
+function nowMs() {
+	return globalThis.performance?.now() ?? Date.now();
+}
+var ColorResolver = class {
+	probe;
+	canvasContext;
+	cache = /* @__PURE__ */ new Map();
+	constructor(root) {
+		this.probe = root.ownerDocument.createElement("span");
+		this.canvasContext = root.ownerDocument.createElement("canvas").getContext("2d", { willReadFrequently: true });
+		this.probe.style.position = "absolute";
+		this.probe.style.visibility = "hidden";
+		this.probe.textContent = ".";
+		root.appendChild(this.probe);
+	}
+	resolve(value, fallback) {
+		if (!value) return fallback;
+		const cached = this.cache.get(value);
+		if (cached) return cached;
+		this.probe.style.color = value;
+		const resolved = this.resolveComputedColor(getComputedStyle(this.probe).color, fallback);
+		this.cache.set(value, resolved);
+		return resolved;
+	}
+	clear() {
+		this.cache.clear();
+	}
+	dispose() {
+		this.clear();
+		this.probe.remove();
+	}
+	resolveComputedColor(value, fallback) {
+		const canvasColor = this.canvasColor(value);
+		if (canvasColor) return canvasColor;
+		return parseCssColor(value, fallback);
+	}
+	canvasColor(value) {
+		const context = this.canvasContext;
+		if (!context) return null;
+		context.clearRect(0, 0, 1, 1);
+		context.fillStyle = value;
+		context.fillRect(0, 0, 1, 1);
+		const [r, g, b, a] = context.getImageData(0, 0, 1, 1).data;
+		return {
+			r: r ?? 0,
+			g: g ?? 0,
+			b: b ?? 0,
+			a: a ?? 0
+		};
+	}
+};
+//#endregion
+export { MinimapWorkerClient, MinimapWorkerOwner, canUseMinimapWorker };
+
+//# sourceMappingURL=workerClient.js.map