@pierre/diffs 1.5.1 → 1.6.0-beta.1

package/dist/worker/shiki-Bx2JpdqZ.js

@@ -0,0 +1,697 @@
+import { i as isWorkerContext, n as DiffsHighlighter, r as createDiffsThemeResolver, t as BaseStreamTokenizer } from "./stream-tokenizer-YZ6M1qSx.js";
+import { c as RegisteredCustomLanguages, l as ResolvedLanguages, r as appendItems, s as attachResolvedLanguages, u as ResolvingLanguages } from "./worker.js";
+import { createCssVariablesTheme, createHighlighterCore } from "shiki/core";
+import { EncodedTokenMetadata, INITIAL } from "shiki/textmate";
+//#region src/highlighter/languages/resolveLanguage.ts
+async function resolveLanguage(lang) {
+	if (typeof __DIFFS_WORKER__ !== "undefined" ? __DIFFS_WORKER__ : isWorkerContext()) throw new Error(`resolveLanguage("${lang}") cannot be called from a worker context. Languages must be pre-resolved on the main thread and passed to the worker via the resolvedLanguages parameter.`);
+	const pending = ResolvingLanguages.get(lang);
+	if (pending != null) return pending;
+	const resolver = (async () => {
+		let loader = RegisteredCustomLanguages.get(lang);
+		if (loader == null) {
+			const { bundledLanguages } = await import("shiki/langs");
+			if (Object.prototype.hasOwnProperty.call(bundledLanguages, lang)) loader = bundledLanguages[lang];
+		}
+		if (loader == null) throw new Error(`resolveLanguage: "${lang}" not found in bundled or custom languages`);
+		const { default: data } = await loader();
+		const resolvedLang = {
+			name: lang,
+			data
+		};
+		if (!ResolvedLanguages.has(lang)) ResolvedLanguages.set(lang, resolvedLang);
+		return resolvedLang;
+	})();
+	ResolvingLanguages.set(lang, resolver);
+	try {
+		return await resolver;
+	} finally {
+		if (ResolvingLanguages.get(lang) === resolver) ResolvingLanguages.delete(lang);
+	}
+}
+//#endregion
+//#region src/highlighter/languages/getResolvedOrResolveLanguage.ts
+function getResolvedOrResolveLanguage(language) {
+	return ResolvedLanguages.get(language) ?? resolveLanguage(language);
+}
+//#endregion
+//#region src/highlighter/languages/resolveLanguages.ts
+async function resolveLanguages(languages) {
+	const resolvedLanguages = [];
+	const languagesToResolve = [];
+	for (const language of languages) {
+		if (language === "text" || language === "ansi") continue;
+		const maybeResolvedLanguage = getResolvedOrResolveLanguage(language) ?? resolveLanguage(language);
+		if ("then" in maybeResolvedLanguage) languagesToResolve.push(maybeResolvedLanguage);
+		else resolvedLanguages.push(maybeResolvedLanguage);
+	}
+	if (languagesToResolve.length > 0) await Promise.all(languagesToResolve).then((_resolvedLanguages) => {
+		for (const resolvedLanguage of _resolvedLanguages) {
+			if (resolvedLanguage == null) throw new Error("resolvedLanguages: unable to resolve language");
+			resolvedLanguages.push(resolvedLanguage);
+		}
+	});
+	return resolvedLanguages;
+}
+//#endregion
+//#region src/editor/utils.ts
+function debounce(func, wait) {
+	let timeout;
+	return function(...args) {
+		clearTimeout(timeout);
+		timeout = setTimeout(() => func.apply(this, args), wait);
+	};
+}
+//#endregion
+//#region src/highlighter/shiki-editor.ts
+const TOKENIZE_TIME_LIMIT = 0;
+let nextTokenizerId = 0;
+/** TextMate state caching and background work for a single editable document. */
+var ShikiEditorTokenizer = class {
+	backend;
+	#highlighter;
+	#grammar;
+	#themeName;
+	#colorMap;
+	#textDocument;
+	#tokenizeMaxLineLength;
+	#onDeferTokenize;
+	#matchBrackets;
+	#debug;
+	#isCleanedUp = false;
+	#stateStack = [INITIAL];
+	#comparisonStateStack = [];
+	#comparisonStateStackStart = 0;
+	#comparisonLineChanges = [];
+	#lastLine = -1;
+	#isStopped = true;
+	#isPaused = false;
+	#backgroundJobId = 0;
+	#tokenizerId = ++nextTokenizerId;
+	#backgroundPrebuildEndLine = -1;
+	#pendingPrebuildEndLine = -1;
+	#backgroundChangedLineRanges;
+	#backgroundChangedRangeIndex = 0;
+	#bracketIgnoredRanges = [];
+	#isMessageListenerAttached = false;
+	#prebuildStateStack = debounce(async (renderRange) => {
+		if (this.#isCleanedUp) return;
+		const { startingLine = 0, totalLines = Infinity } = renderRange ?? {};
+		const endLine = Math.min(totalLines === Infinity ? Infinity : startingLine + totalLines, this.#textDocument.lineCount);
+		if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId)) {
+			await this.backend?.loadLanguages([this.#textDocument.languageId]);
+			if (this.#isCleanedUp) return;
+			this.#grammar = this.#highlighter.getLanguage(this.#textDocument.languageId);
+		}
+		this.#ensureActiveTheme();
+		this.#scheduleStatePrebuild(endLine);
+	}, 500);
+	#onMessage = ({ data }) => {
+		if (typeof data !== "object" || data === null) return;
+		const { type, tokenizerId, jobId } = data;
+		if (type === "tokenize" && tokenizerId === this.#tokenizerId && typeof jobId === "number" && jobId === this.#backgroundJobId) {
+			if (this.#backgroundPrebuildEndLine >= 0) this.#backgroundPrebuild(jobId);
+			else this.#backgroundTokenize(jobId);
+		}
+	};
+	getStringCommentRegexpRangesInLine(lineIndex) {
+		if (!this.#matchBrackets || lineIndex < 0 || lineIndex >= this.#textDocument.lineCount) return null;
+		this.#ensureGrammar();
+		if (this.#grammar == null) return null;
+		if (this.#bracketIgnoredRanges[lineIndex] === void 0) {
+			this.#buildStateStack(lineIndex);
+			const state = this.#stateStack[lineIndex] ?? INITIAL;
+			const result = this.#tokenizeLineAt(lineIndex, state);
+			this.#stateStack[lineIndex + 1] = result.state;
+		}
+		return this.#bracketIgnoredRanges[lineIndex] ?? null;
+	}
+	constructor(highlighter, options, backend) {
+		this.backend = backend;
+		this.#highlighter = highlighter;
+		this.#textDocument = options.textDocument;
+		this.#themeName = options.theme;
+		this.#colorMap = [];
+		this.#tokenizeMaxLineLength = options.tokenizeMaxLineLength ?? 1e3;
+		this.#onDeferTokenize = options.onDeferTokenize;
+		this.#matchBrackets = options.matchBrackets !== false;
+		this.#debug = options.__debug ?? false;
+		this.#ensureGrammar();
+		this.#ensureActiveTheme();
+	}
+	setTheme(themeName) {
+		if (this.#themeName === themeName) return;
+		this.#themeName = themeName;
+		this.#ensureActiveTheme();
+		this.stopBackgroundTokenize();
+		this.#stateStack = [INITIAL];
+		this.#comparisonStateStack = [];
+		this.#comparisonStateStackStart = 0;
+		this.#comparisonLineChanges = [];
+		if (this.#grammar != null && this.#textDocument.lineCount > 0) this.#scheduleBackgroundTokenize(0);
+	}
+	#ensureActiveTheme() {
+		if (this.#themeName === "") return;
+		this.backend?.getTheme(this.#themeName);
+		const { colorMap } = this.#highlighter.setTheme(this.#themeName);
+		this.#colorMap = colorMap;
+	}
+	dispose() {
+		this.#isCleanedUp = true;
+		this.stopBackgroundTokenize();
+		this.#detachMessageListener();
+	}
+	tokenize(change, renderRange, hostRealignsRows = false) {
+		this.#ensureGrammar();
+		this.#ensureActiveTheme();
+		if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId)) throw new Error(`Grammar for language "${this.#textDocument.languageId}" not loaded`);
+		const { lineCount } = this.#textDocument;
+		const { startingLine = 0, totalLines = Infinity } = renderRange ?? {};
+		const renderRangeEndLine = totalLines === Infinity ? lineCount : Math.min(startingLine + totalLines, lineCount);
+		const dirtyStart = change.startLine;
+		const viewStart = Math.max(startingLine, dirtyStart);
+		const crossesRenderRangeEnd = renderRange != null && totalLines !== Infinity && change.lineDelta > 0 && dirtyStart < renderRangeEndLine && change.endLine >= renderRangeEndLine;
+		const canReuseCachedStates = change.lineDelta === 0 && (change.changedLineChanges?.every(([, , lineDelta]) => lineDelta === 0) ?? true);
+		if (this.#matchBrackets && !canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, change.startLine);
+		const canReuseShiftedStates = hostRealignsRows && change.lineDelta !== 0 && dirtyStart >= startingLine;
+		const canCacheTokenizedStates = canReuseCachedStates || renderRange == null || dirtyStart >= viewStart;
+		const changedLineRanges = change.changedLineRanges ?? [[dirtyStart, change.endLine]];
+		this.#comparisonStateStack = [];
+		this.#comparisonStateStackStart = 0;
+		this.#comparisonLineChanges = [];
+		let offscreenSyncEnd = -1;
+		if (dirtyStart < viewStart) {
+			for (const [rangeStart, rangeEnd] of changedLineRanges) if (rangeStart < viewStart) offscreenSyncEnd = Math.max(offscreenSyncEnd, Math.min(rangeEnd, viewStart - 1));
+		}
+		const shouldFlushOffscreenLines = offscreenSyncEnd >= dirtyStart && (canReuseCachedStates || change.lineDelta < 0);
+		if (canReuseCachedStates) this.#buildStateStack(dirtyStart);
+		else {
+			this.#shiftComparisonStateStack(change);
+			if (renderRange == null || dirtyStart >= viewStart) this.#buildStateStack(viewStart);
+		}
+		let changedRangeIndex = 0;
+		let currentChangedRangeEnd = changedLineRanges[changedRangeIndex][1];
+		let backgroundStartLine;
+		let backgroundChangedRangeIndex = 0;
+		let line = canReuseCachedStates ? changedLineRanges[changedRangeIndex][0] : viewStart;
+		let settled = false;
+		const dirtyLines = /* @__PURE__ */ new Map();
+		const offscreenDirtyLines = shouldFlushOffscreenLines ? /* @__PURE__ */ new Map() : void 0;
+		if (offscreenDirtyLines != null && !canReuseCachedStates) {
+			const offscreenEnd = Math.min(offscreenSyncEnd + 1, viewStart, renderRangeEndLine);
+			if (offscreenEnd > dirtyStart) {
+				this.#buildStateStack(offscreenEnd);
+				let offscreenLine = dirtyStart;
+				let offscreenState = this.#stateStack[offscreenLine] ?? INITIAL;
+				for (; offscreenLine < offscreenEnd; offscreenLine++) {
+					const resolved = this.#tokenizeLineAt(offscreenLine, offscreenState);
+					offscreenState = resolved.state;
+					offscreenDirtyLines.set(offscreenLine, resolved.resolvedTokens);
+				}
+				this.#stateStack[offscreenEnd] = offscreenState;
+			}
+		}
+		let state = this.#stateStack[line] ?? INITIAL;
+		for (; line < renderRangeEndLine;) {
+			const previousNextState = canReuseCachedStates ? this.#stateStack[line + 1] : canReuseShiftedStates ? this.#getPreviousEndState(line + 1) : void 0;
+			if (canCacheTokenizedStates) this.#stateStack[line] = state;
+			const { resolvedTokens, state: nextState } = this.#tokenizeLineAt(line, state);
+			state = nextState;
+			if (line >= viewStart) dirtyLines.set(line, resolvedTokens);
+			else offscreenDirtyLines?.set(line, resolvedTokens);
+			if (canCacheTokenizedStates) this.#stateStack[line + 1] = state;
+			settled = line >= currentChangedRangeEnd && (canReuseCachedStates || canReuseShiftedStates) && previousNextState != null && state.equals(previousNextState);
+			if (settled) {
+				changedRangeIndex++;
+				const nextRange = changedLineRanges[changedRangeIndex];
+				if (nextRange == null) break;
+				if (nextRange[0] >= renderRangeEndLine) {
+					backgroundStartLine = nextRange[0];
+					backgroundChangedRangeIndex = changedRangeIndex;
+					break;
+				}
+				let nextState = this.#stateStack[nextRange[0]];
+				if (canReuseShiftedStates) for (let stateLine = line + 2; stateLine <= nextRange[0]; stateLine++) {
+					nextState = this.#getPreviousEndState(stateLine);
+					if (nextState == null) break;
+					this.#stateStack[stateLine] = nextState;
+				}
+				if (nextState == null) {
+					currentChangedRangeEnd = nextRange[1];
+					line++;
+				} else {
+					line = nextRange[0];
+					state = nextState;
+					currentChangedRangeEnd = nextRange[1];
+				}
+				settled = false;
+				continue;
+			}
+			line++;
+		}
+		if (canCacheTokenizedStates) {
+			if (line < renderRangeEndLine) this.#stateStack[line + 1] = state;
+			else this.#stateStack[line] = state;
+		}
+		if (settled && canReuseShiftedStates && backgroundStartLine == null) {
+			for (let stateLine = line + 2; stateLine <= lineCount; stateLine++) {
+				const previousState = this.#getPreviousEndState(stateLine);
+				if (previousState == null) break;
+				this.#stateStack[stateLine] = previousState;
+			}
+			this.#comparisonStateStack = [];
+			this.#comparisonStateStackStart = 0;
+			this.#comparisonLineChanges = [];
+		}
+		if (offscreenDirtyLines != null && offscreenDirtyLines.size > 0) this.#onDeferTokenize(offscreenDirtyLines);
+		if (backgroundStartLine != null) {
+			if (this.#matchBrackets && canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, backgroundStartLine);
+			this.#scheduleBackgroundTokenize(backgroundStartLine, changedLineRanges, backgroundChangedRangeIndex);
+		} else if (!settled && line < lineCount) {
+			const backgroundLine = crossesRenderRangeEnd && dirtyStart >= viewStart ? renderRangeEndLine : dirtyStart < viewStart && !canReuseCachedStates ? dirtyStart : line;
+			if (this.#matchBrackets && canReuseCachedStates) this.#bracketIgnoredRanges.length = Math.min(this.#bracketIgnoredRanges.length, backgroundLine);
+			this.#scheduleBackgroundTokenize(backgroundLine, changedLineRanges, changedRangeIndex);
+		}
+		return dirtyLines;
+	}
+	prebuildStateStack(renderRange) {
+		this.#ensureGrammar();
+		this.#prebuildStateStack(renderRange);
+	}
+	stopBackgroundTokenize() {
+		this.#pendingPrebuildEndLine = -1;
+		if (this.#isStopped) return;
+		this.#isStopped = true;
+		this.#isPaused = false;
+		this.#lastLine = -1;
+		this.#backgroundPrebuildEndLine = -1;
+		this.#backgroundChangedLineRanges = void 0;
+		this.#backgroundChangedRangeIndex = 0;
+		this.#comparisonStateStack = [];
+		this.#comparisonStateStackStart = 0;
+		this.#comparisonLineChanges = [];
+		this.#detachMessageListener();
+	}
+	pauseBackgroundTokenize() {
+		if (this.#isStopped || this.#isPaused) return;
+		if (this.#debug) console.log("[diffs/editor] background tokenization paused", { jobId: this.#backgroundJobId });
+		this.#isPaused = true;
+	}
+	resumeBackgroundTokenize() {
+		if (this.#isStopped || !this.#isPaused || this.#grammar == null || this.#lastLine < 0) return;
+		if (this.#debug) console.log("[diffs/editor] background tokenization resumed", { jobId: this.#backgroundJobId });
+		this.#isPaused = false;
+		this.#postTokenizeMessage(this.#backgroundJobId);
+	}
+	#ensureGrammar() {
+		if (this.#grammar == null && !isGrammarlessLanguage(this.#textDocument.languageId) && this.#highlighter.getLoadedLanguages().includes(this.#textDocument.languageId)) this.#grammar = this.#highlighter.getLanguage(this.#textDocument.languageId);
+	}
+	#attachMessageListener() {
+		if (this.#isMessageListenerAttached) return;
+		globalThis.addEventListener("message", this.#onMessage);
+		this.#isMessageListenerAttached = true;
+	}
+	#detachMessageListener() {
+		if (!this.#isMessageListenerAttached) return;
+		globalThis.removeEventListener("message", this.#onMessage);
+		this.#isMessageListenerAttached = false;
+	}
+	#postTokenizeMessage(jobId) {
+		globalThis.postMessage({
+			type: "tokenize",
+			tokenizerId: this.#tokenizerId,
+			jobId
+		});
+	}
+	#scheduleBackgroundTokenize(startLine, changedLineRanges, changedRangeIndex = 0) {
+		if (isGrammarlessLanguage(this.#textDocument.languageId)) return;
+		const jobId = ++this.#backgroundJobId;
+		if (this.#debug) console.log("[diffs/editor] background tokenization scheduled", {
+			jobId,
+			startLine,
+			changedLineRanges,
+			changedRangeIndex
+		});
+		this.#isStopped = false;
+		this.#isPaused = false;
+		this.#lastLine = startLine;
+		if (this.#backgroundPrebuildEndLine >= 0) this.#pendingPrebuildEndLine = Math.max(this.#pendingPrebuildEndLine, this.#backgroundPrebuildEndLine);
+		this.#backgroundPrebuildEndLine = -1;
+		this.#backgroundChangedLineRanges = changedLineRanges;
+		this.#backgroundChangedRangeIndex = changedRangeIndex;
+		this.#attachMessageListener();
+		this.#postTokenizeMessage(jobId);
+	}
+	#scheduleStatePrebuild(endLine) {
+		if (this.#grammar == null || this.#stateStack.length > endLine) return;
+		if (!this.#isStopped) {
+			if (this.#backgroundPrebuildEndLine >= 0) this.#backgroundPrebuildEndLine = Math.max(this.#backgroundPrebuildEndLine, endLine);
+			else this.#pendingPrebuildEndLine = Math.max(this.#pendingPrebuildEndLine, endLine);
+			return;
+		}
+		const jobId = ++this.#backgroundJobId;
+		this.#isStopped = false;
+		this.#isPaused = false;
+		this.#lastLine = this.#stateStack.length - 1;
+		this.#backgroundPrebuildEndLine = endLine;
+		this.#pendingPrebuildEndLine = -1;
+		this.#backgroundChangedLineRanges = void 0;
+		this.#backgroundChangedRangeIndex = 0;
+		this.#attachMessageListener();
+		this.#postTokenizeMessage(jobId);
+	}
+	#tokenizeLineAt(line, state) {
+		const lineText = this.#textDocument.getLineText(line);
+		if (lineText.length >= this.#tokenizeMaxLineLength) {
+			console.warn(`[diffs] Line(${line}) too long to tokenize: ${lineText.length}`);
+			this.#cacheBracketIgnoredRanges(line, null);
+			return {
+				resolvedTokens: [[
+					0,
+					"",
+					lineText
+				]],
+				state
+			};
+		}
+		if (this.#grammar == null || lineText === "" || lineText.trim() === "") {
+			this.#cacheBracketIgnoredRanges(line, null);
+			return {
+				resolvedTokens: [[
+					0,
+					"",
+					lineText
+				]],
+				state
+			};
+		}
+		const result = tokenizeLine(this.#grammar, this.#colorMap, lineText, state, TOKENIZE_TIME_LIMIT, this.#matchBrackets);
+		this.#cacheBracketIgnoredRanges(line, result.bracketIgnoredRanges);
+		return {
+			resolvedTokens: result.resolvedTokens,
+			state: result.ruleStack
+		};
+	}
+	#cacheBracketIgnoredRanges(line, ranges) {
+		if (this.#matchBrackets) this.#bracketIgnoredRanges[line] = ranges;
+	}
+	#shiftComparisonStateStack(change) {
+		const lineChanges = change.changedLineChanges ?? [[
+			change.startLine,
+			change.endLine,
+			change.lineDelta
+		]];
+		const comparisonStart = change.startLine + 1;
+		if (comparisonStart <= this.#stateStack.length - comparisonStart) {
+			this.#comparisonStateStack = this.#stateStack;
+			this.#comparisonStateStackStart = 0;
+			this.#stateStack = this.#stateStack.slice(0, comparisonStart);
+		} else {
+			this.#comparisonStateStackStart = comparisonStart;
+			this.#comparisonStateStack = this.#stateStack.slice(comparisonStart);
+			this.#stateStack.length = Math.min(this.#stateStack.length, comparisonStart);
+		}
+		this.#comparisonLineChanges = lineChanges;
+	}
+	#getPreviousEndState(line) {
+		let previousLine = line;
+		for (let index = this.#comparisonLineChanges.length - 1; index >= 0; index--) {
+			const [startLine, endLine, lineDelta] = this.#comparisonLineChanges[index];
+			if (lineDelta === 0) continue;
+			if (previousLine > endLine) previousLine -= lineDelta;
+			else if (previousLine > startLine) return this.#stateStack[line];
+		}
+		return this.#comparisonStateStack[previousLine - this.#comparisonStateStackStart] ?? this.#stateStack[line];
+	}
+	#buildStateStack(endAt, timeBudget) {
+		const boundedEndAt = Math.min(Math.max(0, endAt), this.#textDocument.lineCount);
+		if (this.#stateStack.length > boundedEndAt || this.#grammar == null) return true;
+		const startedAt = timeBudget == null ? 0 : performance.now();
+		let line = this.#stateStack.length - 1;
+		let state = this.#stateStack[line] ?? INITIAL;
+		while (line < boundedEndAt) {
+			this.#stateStack[line] = state;
+			const lineText = this.#textDocument.getLineText(line);
+			if (lineText.length < this.#tokenizeMaxLineLength && lineText !== "" && lineText.trim() !== "") {
+				const result = tokenizeLine(this.#grammar, this.#colorMap, lineText, state, TOKENIZE_TIME_LIMIT, this.#matchBrackets, false);
+				this.#cacheBracketIgnoredRanges(line, result.bracketIgnoredRanges);
+				state = result.ruleStack;
+			} else this.#cacheBracketIgnoredRanges(line, null);
+			line++;
+			this.#stateStack[line] = state;
+			if (timeBudget != null && performance.now() - startedAt > timeBudget) break;
+		}
+		return line >= boundedEndAt;
+	}
+	#backgroundPrebuild(jobId) {
+		if (this.#isStopped || this.#isPaused || this.#grammar == null || jobId !== this.#backgroundJobId) return;
+		this.#ensureActiveTheme();
+		const complete = this.#buildStateStack(this.#backgroundPrebuildEndLine, 1);
+		if (this.#isStopped || this.#isPaused || jobId !== this.#backgroundJobId) return;
+		if (complete) {
+			this.stopBackgroundTokenize();
+			return;
+		}
+		this.#lastLine = this.#stateStack.length - 1;
+		this.#postTokenizeMessage(jobId);
+	}
+	#backgroundTokenize(jobId) {
+		if (this.#isStopped || this.#isPaused || this.#grammar == null || jobId !== this.#backgroundJobId) return;
+		this.#ensureActiveTheme();
+		const t = performance.now();
+		const lines = /* @__PURE__ */ new Map();
+		const totalLines = this.#textDocument.lineCount;
+		const changedLineRanges = this.#backgroundChangedLineRanges;
+		let line = this.#lastLine;
+		let state = this.#stateStack[line] ?? INITIAL;
+		let settled = false;
+		let changedRangeIndex = this.#backgroundChangedRangeIndex;
+		let currentChangedRangeEnd = changedLineRanges?.[changedRangeIndex]?.[1];
+		for (; line < totalLines;) {
+			this.#stateStack[line] = state;
+			const previousNextState = currentChangedRangeEnd != null ? this.#getPreviousEndState(line + 1) : void 0;
+			const result = this.#tokenizeLineAt(line, state);
+			lines.set(line, result.resolvedTokens);
+			state = result.state;
+			this.#stateStack[line + 1] = state;
+			settled = currentChangedRangeEnd != null && line >= currentChangedRangeEnd && previousNextState != null && state.equals(previousNextState);
+			line++;
+			if (settled) {
+				changedRangeIndex++;
+				const nextRange = changedLineRanges?.[changedRangeIndex];
+				if (nextRange == null) break;
+				currentChangedRangeEnd = nextRange[1];
+				if (this.#stateStack[nextRange[0]] == null) settled = false;
+				else {
+					line = nextRange[0];
+					state = this.#stateStack[line] ?? state;
+					settled = false;
+					continue;
+				}
+			}
+			if (performance.now() - t > 1) break;
+		}
+		this.#onDeferTokenize(lines);
+		if (this.#isStopped || this.#isPaused || jobId !== this.#backgroundJobId) return;
+		if (settled || line >= totalLines) {
+			const pendingPrebuildEndLine = this.#pendingPrebuildEndLine;
+			this.stopBackgroundTokenize();
+			if (pendingPrebuildEndLine >= 0) this.#scheduleStatePrebuild(pendingPrebuildEndLine);
+			return;
+		}
+		this.#lastLine = line;
+		this.#backgroundChangedRangeIndex = changedRangeIndex;
+		this.#postTokenizeMessage(jobId);
+	}
+};
+function tokenizeLine(grammar, colorMap, lineText, stateStack, timeLimit, collectBracketIgnoredRanges = true, resolveTokens = true) {
+	const result = grammar.tokenizeLine2(lineText, stateStack, timeLimit);
+	if (result.stoppedEarly) console.warn(`[diffs] Time limit reached when tokenizing line: ${lineText.substring(0, 100)}`);
+	const rawTokens = result.tokens;
+	const tokensLength = rawTokens.length / 2;
+	const resolvedTokens = [];
+	const bracketIgnoredRanges = [];
+	if (!resolveTokens && !collectBracketIgnoredRanges) return {
+		ruleStack: result.ruleStack,
+		resolvedTokens,
+		bracketIgnoredRanges
+	};
+	for (let j = 0; j < tokensLength; j++) {
+		const offset = rawTokens[2 * j];
+		const nextOffset = j + 1 < tokensLength ? rawTokens[2 * j + 2] : lineText.length;
+		if (offset === nextOffset) continue;
+		const metadata = rawTokens[2 * j + 1];
+		if (resolveTokens) {
+			const fg = EncodedTokenMetadata.getForeground(metadata);
+			resolvedTokens.push([
+				offset,
+				colorMap[fg],
+				lineText.slice(offset, nextOffset)
+			]);
+		}
+		if (collectBracketIgnoredRanges && EncodedTokenMetadata.getTokenType(metadata) > 0) bracketIgnoredRanges.push([offset, nextOffset]);
+	}
+	return {
+		ruleStack: result.ruleStack,
+		resolvedTokens,
+		bracketIgnoredRanges
+	};
+}
+function isGrammarlessLanguage(languageId) {
+	return languageId === "text" || languageId === "ansi";
+}
+//#endregion
+//#region src/highlighter/shiki-stream.ts
+var ShikiStreamTokenizer = class ShikiStreamTokenizer extends BaseStreamTokenizer {
+	highlighter;
+	options;
+	#tail = "";
+	#grammarState;
+	constructor(highlighter, options) {
+		super();
+		this.highlighter = highlighter;
+		this.options = options;
+	}
+	tokenizeChunk(chunk, stable) {
+		const chunkLines = (this.#tail + chunk).split(/(\r\n|\r|\n)/);
+		let unstable = [];
+		for (let i = 0; i < chunkLines.length; i += 2) {
+			const line = chunkLines[i];
+			const result = this.highlighter.codeToTokens(line, {
+				...this.options,
+				grammarState: this.#grammarState
+			});
+			const tokens = result.tokens[0].map((token) => ({
+				...token,
+				offset: token.offset + this.stableOffset
+			}));
+			if (i + 1 < chunkLines.length) {
+				appendItems(stable, tokens);
+				this.pushLineBreak(stable, line.length, chunkLines[i + 1]);
+				this.#grammarState = result.grammarState;
+			} else {
+				unstable = tokens;
+				this.#tail = line;
+			}
+		}
+		return {
+			unstable,
+			tailLength: this.#tail.length
+		};
+	}
+	clone() {
+		this.assertActive();
+		const clone = new ShikiStreamTokenizer(this.highlighter, this.options);
+		this.copyStateTo(clone);
+		clone.#tail = this.#tail;
+		clone.#grammarState = this.#grammarState;
+		return clone;
+	}
+	resetSource() {
+		this.#tail = "";
+		this.#grammarState = void 0;
+	}
+	releaseSource() {
+		this.resetSource();
+	}
+};
+//#endregion
+//#region src/highlighter/backends/shiki.ts
+var ShikiHighlighter = class ShikiHighlighter extends DiffsHighlighter {
+	raw;
+	loadedThemes = /* @__PURE__ */ new Map();
+	attachedLanguages = /* @__PURE__ */ new Set(["text", "ansi"]);
+	static async create(name) {
+		const engine = name === "shiki-wasm" ? (await import("shiki/engine/oniguruma")).createOnigurumaEngine(import("shiki/wasm")) : (await import("shiki/engine/javascript")).createJavaScriptRegexEngine();
+		const raw = await createHighlighterCore({
+			themes: [],
+			langs: [],
+			engine
+		});
+		return new ShikiHighlighter(name, raw);
+	}
+	constructor(name, raw) {
+		super(name, createDiffsThemeResolver(name));
+		this.raw = raw;
+	}
+	getTheme(themeName) {
+		this.assertNotDisposed();
+		const loaded = this.loadedThemes.get(themeName);
+		const theme = this.themeResolver.getResolvedTheme(themeName) ?? loaded;
+		if (theme == null) throw new Error(`Theme "${themeName}" has not been resolved`);
+		if (loaded !== theme) {
+			const textmate = theme.textmate ?? (theme.cssVariables != null ? createCssVariablesTheme(theme.cssVariables) : void 0);
+			if (textmate == null) throw new Error(`Theme "${themeName}" does not support Shiki`);
+			this.raw.setTheme({
+				...textmate,
+				name: themeName
+			});
+			this.loadedThemes.set(themeName, theme);
+		}
+		return theme;
+	}
+	codeToTokens(code, options) {
+		return this.raw.codeToTokens(code, this.resolveOptions(options));
+	}
+	createEditorTokenizer(options) {
+		return new ShikiEditorTokenizer(this.raw, options, this);
+	}
+	createStreamTokenizer(options) {
+		return new ShikiStreamTokenizer(this.raw, this.resolveOptions(options));
+	}
+	async loadLanguages(languages) {
+		this.assertNotDisposed();
+		const missing = languages.filter((language) => !this.attachedLanguages.has(language));
+		attachResolvedLanguages(await resolveLanguages(missing), this);
+	}
+	hasLoadedLanguages(languages) {
+		if (this.disposed) return false;
+		let loaded;
+		return languages.every((lang) => {
+			if (this.attachedLanguages.has(lang)) return true;
+			if (RegisteredCustomLanguages.has(lang)) return false;
+			loaded ??= this.raw.getLoadedLanguages();
+			return loaded.includes(lang);
+		});
+	}
+	attachLanguages(languages) {
+		this.assertNotDisposed();
+		for (const lang of languages) {
+			if (this.attachedLanguages.has(lang.name)) continue;
+			const grammar = lang.data.find((grammar) => grammar.name === lang.name || grammar.aliases?.includes(lang.name) === true);
+			if (grammar == null) throw new Error(`attachResolvedLanguages: No returned grammar declares "${lang.name}" as its name or an alias.`);
+			this.raw.loadLanguageSync(lang.data);
+			try {
+				this.raw.getLanguage(lang.name);
+			} catch {
+				throw new Error(`attachResolvedLanguages: "${grammar.name}" is already loaded without alias "${lang.name}". Load the alias first or give the grammar a unique name.`);
+			}
+			this.attachedLanguages.add(lang.name);
+		}
+	}
+	releaseResources() {
+		this.loadedThemes.clear();
+		this.attachedLanguages.clear();
+		this.raw.dispose();
+	}
+	resolveOptions({ theme, themes, ...options }) {
+		this.assertNotDisposed();
+		if (theme != null) {
+			this.getTheme(theme);
+			return {
+				...options,
+				theme
+			};
+		}
+		if (themes == null) throw new Error("A theme or themes option is required");
+		for (const name of Object.values(themes)) this.getTheme(name);
+		return {
+			...options,
+			themes
+		};
+	}
+};
+//#endregion
+export { ShikiHighlighter };
+
+//# sourceMappingURL=shiki-Bx2JpdqZ.js.map