@actis/codemirror 26.9.0

package/dist/index.cjs

@@ -0,0 +1,731 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _codemirror_autocomplete = require("@codemirror/autocomplete");
+let _codemirror_lang_cpp = require("@codemirror/lang-cpp");
+let _codemirror_view = require("@codemirror/view");
+let codemirror = require("codemirror");
+let _codemirror_state = require("@codemirror/state");
+let _codemirror_language = require("@codemirror/language");
+let _codemirror_lint = require("@codemirror/lint");
+let _lezer_highlight = require("@lezer/highlight");
+//#region src/plugin/bracket-match.ts
+const MATCH = new Map([
+	["(", ")"],
+	["[", "]"],
+	["{", "}"]
+]);
+const OPEN = new Set(MATCH.keys());
+const CLOSE = new Set(MATCH.values());
+function findUnmatchedBrackets(doc) {
+	const stack = [];
+	const unmatched = [];
+	let offset = 0;
+	const iter = doc.iter();
+	while (!iter.next().done) {
+		const chunk = iter.value;
+		for (let i = 0; i < chunk.length; i++) {
+			const ch = chunk[i];
+			if (OPEN.has(ch)) stack.push({
+				char: ch,
+				pos: offset + i
+			});
+			else if (CLOSE.has(ch)) {
+				const top = stack.at(-1);
+				if (top && MATCH.get(top.char) === ch) stack.pop();
+				else unmatched.push(offset + i);
+			}
+		}
+		offset += chunk.length;
+	}
+	for (const { pos } of stack) unmatched.push(pos);
+	return unmatched.sort((a, b) => a - b);
+}
+const unmatchedDecoration = _codemirror_view.Decoration.mark({ class: "cm-nonmatchingBracket" });
+function buildDecorations(doc) {
+	const builder = new _codemirror_state.RangeSetBuilder();
+	for (const pos of findUnmatchedBrackets(doc)) builder.add(pos, pos + 1, unmatchedDecoration);
+	return builder.finish();
+}
+const nonMatchingBracketPlugin = _codemirror_view.ViewPlugin.fromClass(class {
+	constructor(view) {
+		this.decorations = buildDecorations(view.state.doc);
+	}
+	update(update) {
+		if (update.docChanged) this.decorations = buildDecorations(update.state.doc);
+	}
+}, { decorations: (v) => v.decorations });
+//#endregion
+//#region src/plugin/completions.ts
+const WEBGL_KEYWORDS = [
+	"precision",
+	"lowp",
+	"mediump",
+	"highp",
+	"attribute",
+	"uniform",
+	"varying",
+	"break",
+	"continue",
+	"do",
+	"for",
+	"while",
+	"if",
+	"else",
+	"float",
+	"int",
+	"void",
+	"bool",
+	"mat2",
+	"mat3",
+	"mat4",
+	"vec2",
+	"vec3",
+	"vec4",
+	"ivec2",
+	"ivec3",
+	"ivec4",
+	"bvec2",
+	"bvec3",
+	"bvec4",
+	"sampler2D",
+	"samplerCube",
+	"struct",
+	"discard",
+	"return"
+];
+const WEBGL2_KEYWORDS = [
+	"layout",
+	"flat",
+	"smooth",
+	"noperspective",
+	"switch",
+	"case",
+	"default",
+	"uint",
+	"uvec2",
+	"uvec3",
+	"uvec4",
+	"mat2x2",
+	"mat2x3",
+	"mat2x4",
+	"mat3x2",
+	"mat3x3",
+	"mat3x4",
+	"mat4x2",
+	"mat4x3",
+	"mat4x4",
+	"isampler2D",
+	"isampler3D",
+	"isamplerCube",
+	"usampler2D",
+	"usampler3D",
+	"usamplerCube"
+];
+const SNIPPETS = [{
+	label: "main",
+	detail: "main entry point",
+	type: "function",
+	template: "void main() {\n	${}\n	gl_FragColor = vec4(1.0);\n}"
+}, {
+	label: "for",
+	detail: "for loop",
+	type: "keyword",
+	template: "for (int i = 0; i < ${count}; i++) {\n	${}\n}"
+}];
+const WORD_PATTERN = /\w*/;
+function glslCompletions(options = {}) {
+	const completions = [...[...WEBGL_KEYWORDS, ...options.webgl2 ? WEBGL2_KEYWORDS : []].map((kw) => ({
+		label: kw,
+		type: "keyword"
+	})), ...SNIPPETS.map((s) => (0, _codemirror_autocomplete.snippetCompletion)(s.template, {
+		label: s.label,
+		detail: s.detail,
+		type: s.type
+	}))];
+	return (context) => {
+		const word = context.matchBefore(WORD_PATTERN);
+		if (!word || word.from === word.to && !context.explicit) return null;
+		return {
+			from: word.from,
+			options: completions
+		};
+	};
+}
+//#endregion
+//#region src/plugin/folding.ts
+function codeFoldingExtension() {
+	return [(0, _codemirror_language.codeFolding)({
+		preparePlaceholder(state, range) {
+			const from = state.doc.lineAt(range.from).number;
+			return `${state.doc.lineAt(range.to).number - from} lines`;
+		},
+		placeholderDOM(_view, onclick, text) {
+			const placeholder = document.createElement("span");
+			placeholder.className = "cm-fold-placeholder";
+			placeholder.textContent = text;
+			placeholder.setAttribute("role", "button");
+			placeholder.setAttribute("aria-label", "unfold code");
+			placeholder.setAttribute("title", "Click to unfold");
+			placeholder.setAttribute("tabindex", "0");
+			placeholder.style.touchAction = "manipulation";
+			placeholder.addEventListener("click", onclick);
+			placeholder.addEventListener("keydown", (e) => {
+				if (e.key === "Enter" || e.key === " ") {
+					e.preventDefault();
+					onclick(e);
+				}
+			});
+			return placeholder;
+		}
+	})];
+}
+//#endregion
+//#region src/plugin/scrollbar.ts
+const scrollbarRuler = _codemirror_view.ViewPlugin.fromClass(class {
+	constructor(view) {
+		this.view = view;
+		this.rectPool = [];
+		this.trackHeight = 0;
+		this.scrollHeight = 0;
+		this.clientHeight = 0;
+		this.thumbHeight = 0;
+		this.TRACK_WIDTH = 15;
+		this.onThumbPointerDown = (e) => {
+			e.stopPropagation();
+			e.preventDefault();
+			this.thumb.setPointerCapture(e.pointerId);
+			const startY = e.clientY;
+			const startScrollTop = this.view.scrollDOM.scrollTop;
+			const onMove = (ev) => {
+				const maxThumbTop = this.trackHeight - this.thumbHeight;
+				const maxScrollTop = this.scrollHeight - this.clientHeight;
+				if (maxThumbTop <= 0) return;
+				this.view.scrollDOM.scrollTop = startScrollTop + (ev.clientY - startY) * (maxScrollTop / maxThumbTop);
+			};
+			const onUp = () => {
+				this.thumb.removeEventListener("pointermove", onMove);
+				this.thumb.removeEventListener("pointerup", onUp);
+			};
+			this.thumb.addEventListener("pointermove", onMove);
+			this.thumb.addEventListener("pointerup", onUp);
+		};
+		this.onTrackPointerDown = (e) => {
+			if (e.target === this.thumb) return;
+			e.preventDefault();
+			const rect = this.inner.getBoundingClientRect();
+			const clickFraction = Math.max(0, Math.min(1, (e.clientY - rect.top - this.thumbHeight / 2) / (this.trackHeight - this.thumbHeight)));
+			this.view.scrollDOM.scrollTop = clickFraction * (this.scrollHeight - this.clientHeight);
+		};
+		this.syncThumb = () => {
+			const maxScroll = this.scrollHeight - this.clientHeight;
+			if (maxScroll <= 0) {
+				this.thumb.style.display = "none";
+				return;
+			}
+			this.thumb.style.display = "";
+			const thumbTop = this.view.scrollDOM.scrollTop / maxScroll * (this.trackHeight - this.thumbHeight);
+			this.thumb.style.transform = `translate3d(0, ${thumbTop}px, 0)`;
+		};
+		this.gutter = document.createElement("div");
+		this.gutter.className = "cm-scrollbar-gutter";
+		this.inner = document.createElement("div");
+		this.inner.className = "cm-scrollbar-inner";
+		this.svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+		this.svg.setAttribute("aria-hidden", "true");
+		this.svg.style.display = "block";
+		this.svg.style.width = "100%";
+		this.thumb = document.createElement("div");
+		this.thumb.className = "cm-scrollbar-thumb";
+		this.thumb.style.willChange = "transform";
+		this.inner.appendChild(this.svg);
+		this.inner.appendChild(this.thumb);
+		this.gutter.appendChild(this.inner);
+		view.dom.classList.add("cm-with-scrollbar");
+		view.dom.appendChild(this.gutter);
+		this.cursorRect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+		this.cursorRect.setAttribute("x", "0");
+		this.cursorRect.setAttribute("y", "0");
+		this.cursorRect.setAttribute("width", `${this.TRACK_WIDTH}`);
+		this.cursorRect.setAttribute("height", "2");
+		this.cursorRect.setAttribute("fill", "var(--cm-foreground, #888)");
+		this.cursorRect.style.willChange = "transform";
+		this.svg.appendChild(this.cursorRect);
+		this.thumb.addEventListener("pointerdown", this.onThumbPointerDown);
+		this.inner.addEventListener("pointerdown", this.onTrackPointerDown);
+		this.view.scrollDOM.addEventListener("scroll", this.syncThumb, { passive: true });
+		this.measureAndPaint();
+	}
+	update(update) {
+		let needsFullPaint = false;
+		if (update.geometryChanged) {
+			this.measure();
+			needsFullPaint = true;
+		}
+		if (update.docChanged || update.transactions.some((t) => t.effects.length > 0)) needsFullPaint = true;
+		if (needsFullPaint) this.paintMarkers();
+		if (update.selectionSet || needsFullPaint) this.paintCursor();
+	}
+	measure() {
+		const scrollDOM = this.view.scrollDOM;
+		this.scrollHeight = scrollDOM.scrollHeight;
+		this.clientHeight = scrollDOM.clientHeight;
+		const scrollerRect = scrollDOM.getBoundingClientRect();
+		const editorRect = this.view.dom.getBoundingClientRect();
+		this.trackHeight = scrollerRect.height;
+		this.gutter.style.top = `${scrollerRect.top - editorRect.top}px`;
+		this.gutter.style.height = `${this.trackHeight}px`;
+		this.svg.setAttribute("height", `${this.trackHeight}`);
+		const newThumbHeight = Math.max(20, this.clientHeight / this.scrollHeight * this.trackHeight);
+		if (Math.abs(this.thumbHeight - newThumbHeight) > .5) {
+			this.thumbHeight = newThumbHeight;
+			this.thumb.style.height = `${newThumbHeight}px`;
+		}
+	}
+	measureAndPaint() {
+		this.measure();
+		this.paintMarkers();
+		this.paintCursor();
+		this.syncThumb();
+	}
+	paintCursor() {
+		const { state } = this.view;
+		if (state.doc.length === 0 || this.scrollHeight <= 0) return;
+		const y = this.posToY(state.selection.main.head);
+		this.cursorRect.style.transform = `translate3d(0, ${y}px, 0)`;
+	}
+	paintMarkers() {
+		const { state } = this.view;
+		if (state.doc.length === 0 || this.trackHeight <= 0 || this.scrollHeight <= 0) return;
+		let i = 0;
+		(0, _codemirror_lint.forEachDiagnostic)(state, (diag) => {
+			if (diag.severity !== "error") return;
+			const top = this.posToY(diag.from);
+			const bottom = this.posToY(diag.to);
+			const height = Math.max(3, bottom - top);
+			let rect;
+			if (i < this.rectPool.length) rect = this.rectPool[i];
+			else {
+				rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+				rect.setAttribute("x", "0");
+				rect.setAttribute("y", "0");
+				rect.setAttribute("width", `${this.TRACK_WIDTH}`);
+				rect.setAttribute("height", "1");
+				rect.setAttribute("fill", "#ff5555");
+				rect.style.transformOrigin = "0 0";
+				this.svg.insertBefore(rect, this.cursorRect);
+				this.rectPool.push(rect);
+			}
+			rect.style.transform = `translate3d(0, ${top}px, 0) scaleY(${height})`;
+			rect.style.display = "";
+			i++;
+		});
+		while (i < this.rectPool.length) {
+			this.rectPool[i].style.display = "none";
+			i++;
+		}
+	}
+	posToY(pos) {
+		if (this.scrollHeight <= 0) return 0;
+		const safePos = Math.max(0, Math.min(pos, this.view.state.doc.length));
+		return (this.view.lineBlockAt(safePos).top + this.view.documentPadding.top) / this.scrollHeight * this.trackHeight;
+	}
+	destroy() {
+		this.thumb.removeEventListener("pointerdown", this.onThumbPointerDown);
+		this.inner.removeEventListener("pointerdown", this.onTrackPointerDown);
+		this.view.scrollDOM.removeEventListener("scroll", this.syncThumb);
+		this.gutter.remove();
+	}
+});
+const scrollbarRulerTheme = _codemirror_view.EditorView.baseTheme({
+	".cm-scrollbar-gutter": {
+		position: "absolute",
+		right: "0",
+		width: "0.938rem",
+		pointerEvents: "auto",
+		overflow: "hidden",
+		zIndex: 10,
+		userSelect: "none"
+	},
+	".cm-scrollbar-inner": {
+		position: "relative",
+		width: "100%",
+		height: "100%",
+		backgroundColor: "rgba(0, 0, 0, 0.1)",
+		cursor: "pointer"
+	},
+	".cm-scrollbar-inner svg": {
+		position: "absolute",
+		top: "0",
+		left: "0",
+		height: "100%",
+		pointerEvents: "none"
+	},
+	".cm-scrollbar-thumb": {
+		position: "absolute",
+		left: "0",
+		right: "0",
+		backgroundColor: "rgba(128, 128, 128, 0.3)",
+		pointerEvents: "auto",
+		cursor: "default",
+		zIndex: 11
+	},
+	".cm-scrollbar-thumb:hover": { backgroundColor: "rgba(128, 128, 128, 0.5)" },
+	".cm-scrollbar-thumb:active": { backgroundColor: "rgba(128, 128, 128, 0.6)" },
+	".cm-scroller": {
+		scrollbarWidth: "none",
+		msOverflowStyle: "none"
+	},
+	".cm-scroller::-webkit-scrollbar": { display: "none" }
+});
+function scrollbarRulerExtension() {
+	return [scrollbarRuler, scrollbarRulerTheme];
+}
+//#endregion
+//#region src/plugin/selection.ts
+const selectionLineHighlightPlugin = _codemirror_view.ViewPlugin.fromClass(class {
+	update(update) {
+		if (update.selectionSet || update.docChanged) {
+			const { state, dom } = update.view;
+			if (state.selection.ranges.some((r) => !r.empty)) {
+				dom.style.setProperty("--cm-line-highlight-background", "transparent");
+				dom.style.setProperty("--cm-line-highlight-border", "transparent");
+			} else {
+				dom.style.removeProperty("--cm-line-highlight-background");
+				dom.style.removeProperty("--cm-line-highlight-border");
+			}
+		}
+	}
+});
+//#endregion
+//#region src/plugin/theme.ts
+const keyword = "var(--cm-keyword)";
+const property = "var(--cm-property)";
+const punctuation = "var(--cm-punctuation)";
+const invalid = "var(--cm-invalid, #ffffff)";
+const foreground = "var(--cm-foreground)";
+const lineNumber = "var(--cm-line-number)";
+const comment = "var(--cm-comment)";
+const variable = "var(--cm-variable)";
+const string = "var(--cm-string)";
+const darkBackground = "var(--cm-background)";
+const highlightBackground = "var(--cm-line-highlight-background)";
+const background = "var(--cm-background)";
+const tooltipBackground = "var(--cm-tooltip-background)";
+const selection = "var(--cm-selection-background)";
+const border = "var(--cm-border)";
+const cursor = "var(--cm-cursor, #888)";
+const vitesseTheme = _codemirror_view.EditorView.theme({
+	"&": {
+		color: foreground,
+		backgroundColor: background,
+		fontFamily: "var(--cm-font-family)",
+		fontSize: "var(--cm-font-size, 14px)",
+		lineHeight: "var(--cm-line-height, 1.6)",
+		fontVariantLigatures: "var(--cm-font-ligatures, normal)",
+		fontFeatureSettings: "var(--cm-font-feature-settings, \"calt\" 1)"
+	},
+	"& div": { flexDirection: "initial" },
+	"&.cm-focused": { outline: "none" },
+	".cm-content": { caretColor: cursor },
+	".cm-completionIcon": { display: "none" },
+	".cm-cursor, .cm-dropCursor": { borderLeftColor: cursor },
+	"&.cm-focused .cm-selectionBackground, .cm-selectionBackground, .cm-content ::selection": { backgroundColor: `${selection} !important` },
+	".cm-panels": {
+		backgroundColor: darkBackground,
+		color: foreground
+	},
+	".cm-panels.cm-panels-top": { borderBottom: "1px solid var(--cm-border)" },
+	".cm-panels.cm-panels-bottom": { borderTop: "1px solid var(--cm-border)" },
+	".cm-searchMatch": {
+		backgroundColor: "var(--cm-search-match-background, #72a1ff59)",
+		outline: "1px solid var(--cm-search-match-outline, #457dff)"
+	},
+	".cm-searchMatch.cm-searchMatch-selected": { backgroundColor: "var(--cm-search-match-selected-background, #6199ff2f)" },
+	".cm-line": {
+		border: "1px solid transparent",
+		lineHeight: "inherit"
+	},
+	".cm-activeLine": {
+		backgroundColor: highlightBackground,
+		border: "1px solid var(--cm-line-highlight-border)"
+	},
+	".cm-selectionMatch": { backgroundColor: "var(--cm-selection-match-background, #aafe661a)" },
+	"&.cm-focused .cm-matchingBracket": {
+		backgroundColor: "var(--cm-matching-bracket-background)",
+		textDecoration: "underline",
+		textUnderlineOffset: "var(--cm-bracket-underline-offset, 2px)"
+	},
+	"&.cm-focused .cm-nonmatchingBracket": {
+		backgroundColor: "var(--cm-nonmatching-bracket-background)",
+		outline: "1px solid color-mix(in srgb, var(--cm-nonmatching-bracket-background), white 25%)",
+		borderRadius: "2px"
+	},
+	".cm-gutters": {
+		backgroundColor: background,
+		color: lineNumber,
+		border: "none",
+		fontFamily: "var(--cm-font-family)"
+	},
+	".cm-activeLineGutter": {
+		backgroundColor: "transparent",
+		color: "var(--cm-active-line-gutter, #bfbaaa)"
+	},
+	".cm-foldPlaceholder": {
+		backgroundColor: "transparent",
+		border: "none",
+		color: "var(--cm-fold-placeholder-color, #ddd)"
+	},
+	".cm-tooltip": {
+		border: `1px solid ${border}`,
+		borderRadius: "4px",
+		backgroundColor: tooltipBackground,
+		color: "var(--cm-tooltip-foreground, #c2beb3)",
+		fontFamily: "var(--cm-font-family)"
+	},
+	".cm-tooltip .cm-tooltip-arrow:before": {
+		borderTopColor: "transparent",
+		borderBottomColor: "transparent"
+	},
+	".cm-tooltip .cm-tooltip-arrow:after": {
+		borderTopColor: tooltipBackground,
+		borderBottomColor: tooltipBackground
+	},
+	".cm-tooltip-autocomplete": { "& > ul > li[aria-selected]": {
+		backgroundColor: selection,
+		color: "var(--cm-tooltip-foreground, #c2beb3)"
+	} }
+}, { dark: true });
+const vitesseHighlightStyle = _codemirror_language.HighlightStyle.define([
+	{
+		tag: [_lezer_highlight.tags.variableName, _lezer_highlight.tags.regexp],
+		color: "var(--cm-decorator)"
+	},
+	{
+		tag: [
+			_lezer_highlight.tags.name,
+			_lezer_highlight.tags.deleted,
+			_lezer_highlight.tags.character,
+			_lezer_highlight.tags.propertyName,
+			_lezer_highlight.tags.macroName
+		],
+		color: property
+	},
+	{
+		tag: [_lezer_highlight.tags.function(_lezer_highlight.tags.variableName), _lezer_highlight.tags.labelName],
+		color: variable
+	},
+	{
+		tag: [
+			_lezer_highlight.tags.color,
+			_lezer_highlight.tags.constant(_lezer_highlight.tags.name),
+			_lezer_highlight.tags.standard(_lezer_highlight.tags.name)
+		],
+		color: "var(--cm-constant, #c99076)"
+	},
+	{
+		tag: [_lezer_highlight.tags.definition(_lezer_highlight.tags.name), _lezer_highlight.tags.separator],
+		color: foreground
+	},
+	{
+		tag: [_lezer_highlight.tags.angleBracket],
+		color: "var(--cm-angle-bracket, #666666)"
+	},
+	{
+		tag: [_lezer_highlight.tags.brace],
+		color: "var(--cm-brace, #5eaab5)"
+	},
+	{
+		tag: [_lezer_highlight.tags.bracket],
+		color: "var(--cm-bracket, #4d9375)"
+	},
+	{
+		tag: [
+			_lezer_highlight.tags.typeName,
+			_lezer_highlight.tags.className,
+			_lezer_highlight.tags.number,
+			_lezer_highlight.tags.changed,
+			_lezer_highlight.tags.annotation,
+			_lezer_highlight.tags.modifier,
+			_lezer_highlight.tags.self,
+			_lezer_highlight.tags.namespace,
+			_lezer_highlight.tags.keyword,
+			_lezer_highlight.tags.atom,
+			_lezer_highlight.tags.bool,
+			_lezer_highlight.tags.special(_lezer_highlight.tags.variableName)
+		],
+		color: keyword
+	},
+	{
+		tag: [_lezer_highlight.tags.definitionKeyword],
+		color: "var(--cm-definition-keyword)"
+	},
+	{
+		tag: [
+			_lezer_highlight.tags.operator,
+			_lezer_highlight.tags.operatorKeyword,
+			_lezer_highlight.tags.url,
+			_lezer_highlight.tags.escape,
+			_lezer_highlight.tags.link,
+			_lezer_highlight.tags.special(_lezer_highlight.tags.string)
+		],
+		color: punctuation
+	},
+	{
+		tag: [_lezer_highlight.tags.meta, _lezer_highlight.tags.comment],
+		color: comment
+	},
+	{
+		tag: _lezer_highlight.tags.strong,
+		fontWeight: "var(--cm-font-weight-bold, bold)"
+	},
+	{
+		tag: _lezer_highlight.tags.emphasis,
+		fontStyle: "var(--cm-font-style-italic, italic)"
+	},
+	{
+		tag: _lezer_highlight.tags.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: _lezer_highlight.tags.link,
+		color: lineNumber,
+		textDecoration: "underline"
+	},
+	{
+		tag: _lezer_highlight.tags.heading,
+		fontWeight: "var(--cm-font-weight-bold, bold)",
+		color: property
+	},
+	{
+		tag: [
+			_lezer_highlight.tags.processingInstruction,
+			_lezer_highlight.tags.string,
+			_lezer_highlight.tags.inserted
+		],
+		color: string
+	},
+	{
+		tag: _lezer_highlight.tags.invalid,
+		color: invalid
+	}
+]);
+const vitesse = [vitesseTheme, (0, _codemirror_language.syntaxHighlighting)(vitesseHighlightStyle)];
+//#endregion
+//#region src/plugin/word-highlight.ts
+const WORD_BEFORE_PATTERN = /\w*$/;
+const WORD_AFTER_PATTERN = /^\w*/;
+const ESCAPE_REGEX_PATTERN = /[.*+?^${}()|[\]\\]/g;
+function escapeRegExp(string) {
+	return string.replace(ESCAPE_REGEX_PATTERN, "\\$&");
+}
+const wordHighlightPlugin = _codemirror_view.ViewPlugin.fromClass(class {
+	constructor() {
+		this.decorations = _codemirror_view.Decoration.none;
+		this.cachedWord = null;
+		this.cachedDecorations = null;
+	}
+	update(update) {
+		if (update.selectionSet || update.docChanged) {
+			const word = this.getCurrentWord(update.view);
+			if (word !== this.cachedWord || update.docChanged) {
+				this.cachedWord = word;
+				if (word) this.cachedDecorations = this.buildDecorations(update.view, word);
+				else this.cachedDecorations = _codemirror_view.Decoration.none;
+				this.decorations = this.cachedDecorations;
+			}
+		}
+	}
+	getCurrentWord(view) {
+		const { state } = view;
+		const { selection, doc } = state;
+		for (const range of selection.ranges) if (range.empty) {
+			const pos = range.head;
+			const line = doc.lineAt(pos);
+			const text = line.text;
+			const offset = pos - line.from;
+			const beforeMatch = text.slice(0, offset).match(WORD_BEFORE_PATTERN);
+			const afterMatch = text.slice(offset).match(WORD_AFTER_PATTERN);
+			if (beforeMatch && afterMatch) {
+				const wordStart = offset - beforeMatch[0].length;
+				const word = text.slice(wordStart, wordStart + beforeMatch[0].length + afterMatch[0].length);
+				if (word.length > 0) {
+					if ((wordStart > 0 ? text[wordStart - 1] : "") === ".") return null;
+					return word;
+				}
+			}
+		}
+		return null;
+	}
+	buildDecorations(view, word) {
+		const { doc } = view.state;
+		const builder = new _codemirror_state.RangeSetBuilder();
+		const escapedWord = escapeRegExp(word);
+		const pattern = new RegExp(`(?<!\\.)\\b${escapedWord}\\b`, "g");
+		for (let lineNum = 1; lineNum <= doc.lines; lineNum++) {
+			const line = doc.line(lineNum);
+			pattern.lastIndex = 0;
+			let match;
+			while (true) {
+				match = pattern.exec(line.text);
+				if (match === null) break;
+				const from = line.from + match.index;
+				const to = from + match[0].length;
+				builder.add(from, to, _codemirror_view.Decoration.mark({ class: "cm-word-highlight" }));
+			}
+		}
+		return builder.finish();
+	}
+}, { decorations: (v) => v.decorations });
+const wordHighlightTheme = _codemirror_view.EditorView.baseTheme({ ".cm-word-highlight": {
+	backgroundColor: "var(--cm-word-highlight-background, hsl(210 91% 61% / 0.15))",
+	borderRadius: "2px"
+} });
+function wordHighlightExtension() {
+	return [wordHighlightPlugin, wordHighlightTheme];
+}
+//#endregion
+//#region src/glsl.ts
+const actisCodeMirrorClassName = "cm-actis-editor";
+function glslLanguage() {
+	return (0, _codemirror_lang_cpp.cpp)();
+}
+function glslEditorExtensions(options = {}) {
+	const extensions = [];
+	const basicSetup = options.basicSetup === void 0 ? codemirror.basicSetup : options.basicSetup;
+	if (basicSetup !== false) extensions.push(basicSetup);
+	const language = options.language === void 0 ? glslLanguage() : options.language;
+	if (language !== false) extensions.push(language);
+	const theme = options.theme === void 0 ? vitesse : options.theme;
+	if (theme !== false) extensions.push(theme);
+	if (options.nonMatchingBrackets !== false) extensions.push(nonMatchingBracketPlugin);
+	if (options.wordHighlight !== false) extensions.push(wordHighlightExtension());
+	if (options.selectionLineHighlight !== false) extensions.push(selectionLineHighlightPlugin);
+	if (options.scrollbar !== false) extensions.push(scrollbarRulerExtension());
+	if (options.scrollPastEnd !== false) extensions.push((0, _codemirror_view.scrollPastEnd)());
+	if (options.folding !== false) extensions.push(codeFoldingExtension());
+	const completionSource = options.completionSource === void 0 ? glslCompletions(options) : options.completionSource;
+	if (completionSource !== false) extensions.push((0, _codemirror_autocomplete.autocompletion)({
+		activateOnTyping: true,
+		override: [completionSource]
+	}));
+	if (options.onChange) extensions.push(_codemirror_view.EditorView.updateListener.of((update) => {
+		if (update.docChanged) options.onChange?.(update.state.doc.toString(), update);
+	}));
+	return extensions;
+}
+//#endregion
+exports.actisCodeMirrorClassName = actisCodeMirrorClassName;
+exports.codeFoldingExtension = codeFoldingExtension;
+exports.glslCompletions = glslCompletions;
+exports.glslEditorExtensions = glslEditorExtensions;
+exports.glslLanguage = glslLanguage;
+exports.nonMatchingBracketPlugin = nonMatchingBracketPlugin;
+exports.scrollbarRuler = scrollbarRuler;
+exports.scrollbarRulerExtension = scrollbarRulerExtension;
+exports.scrollbarRulerTheme = scrollbarRulerTheme;
+exports.selectionLineHighlightPlugin = selectionLineHighlightPlugin;
+exports.vitesse = vitesse;
+exports.vitesseHighlightStyle = vitesseHighlightStyle;
+exports.vitesseTheme = vitesseTheme;
+exports.wordHighlightExtension = wordHighlightExtension;
+exports.wordHighlightPlugin = wordHighlightPlugin;
+exports.wordHighlightTheme = wordHighlightTheme;