@bud.sh/app 0.1.0 → 0.2.0

package/dist/node-host/assets/cloneFileDiffMetadata-C1BcNpxN.js

@@ -0,0 +1,3075 @@
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/constants.js
+var DIFFS_TAG_NAME = "diffs-container";
+var DIFFS_DEVELOPMENT_BUILD = (() => {
+	try {
+		return process.env.NODE_ENV === "development";
+	} catch {
+		return false;
+	}
+})();
+var GIT_DIFF_FILE_BREAK_REGEX = /(?=^diff --git)/gm;
+var SPLIT_WITH_NEWLINES = /(?<=\n)/;
+var FILENAME_HEADER_REGEX = /^(---|\+\+\+)\s+([^\t\r\n]+)/;
+var INDEX_LINE_METADATA = /^index ([0-9a-f]+)\.\.([0-9a-f]+)(?: (\d+))?$/i;
+var HEADER_PREFIX_SLOT_ID = "header-prefix";
+var HEADER_FILENAME_SUFFIX_SLOT_ID = "header-filename-suffix";
+var HEADER_METADATA_SLOT_ID = "header-metadata";
+var CUSTOM_HEADER_SLOT_ID = "header-custom";
+var DEFAULT_THEMES = {
+	dark: "pierre-dark",
+	light: "pierre-light"
+};
+var THEME_CSS_ATTRIBUTE = "data-theme-css";
+var UNSAFE_CSS_ATTRIBUTE = "data-unsafe-css";
+var DIFFS_SCROLLBAR_MEASURE_ATTRIBUTE = "data-diffs-scrollbar-measure";
+var CODE_VIEW_HEADER_ATTRIBUTE = "data-diffs-code-view-header";
+var CODE_VIEW_FOOTER_ATTRIBUTE = "data-diffs-code-view-footer";
+var DIFFS_SCROLLBAR_GUTTER_MEASURED_PROPERTY = "--diffs-scrollbar-gutter-measured";
+var DEFAULT_TOKENIZE_MAX_LENGTH = 1e5;
+var DEFAULT_VIRTUAL_FILE_METRICS = {
+	hunkLineCount: 50,
+	lineHeight: 20,
+	diffHeaderHeight: 44,
+	spacing: 8
+};
+var DEFAULT_CODE_VIEW_FILE_METRICS = {
+	...DEFAULT_VIRTUAL_FILE_METRICS,
+	hunkLineCount: 1
+};
+var DEFAULT_CODE_VIEW_LAYOUT = {
+	paddingTop: 8,
+	paddingBottom: 8,
+	gap: 8
+};
+var DEFAULT_SMOOTH_SCROLL_SETTINGS = {
+	omega: .015,
+	positionEpsilon: .5,
+	velocityEpsilon: .05
+};
+var DEFAULT_EXPANDED_REGION = Object.freeze({
+	fromStart: 0,
+	fromEnd: 0
+});
+var DEFAULT_RENDER_RANGE = {
+	startingLine: 0,
+	totalLines: Infinity,
+	bufferBefore: 0,
+	bufferAfter: 0
+};
+var EMPTY_RENDER_RANGE = {
+	startingLine: 0,
+	totalLines: 0,
+	bufferBefore: 0,
+	bufferAfter: 0
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@shikijs+vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.js
+function clone(something) {
+	return doClone(something);
+}
+function doClone(something) {
+	if (Array.isArray(something)) return cloneArray(something);
+	if (something instanceof RegExp) return something;
+	if (typeof something === "object") return cloneObj(something);
+	return something;
+}
+function cloneArray(arr) {
+	let r = [];
+	for (let i = 0, len = arr.length; i < len; i++) r[i] = doClone(arr[i]);
+	return r;
+}
+function cloneObj(obj) {
+	let r = {};
+	for (let key in obj) r[key] = doClone(obj[key]);
+	return r;
+}
+function mergeObjects(target, ...sources) {
+	sources.forEach((source) => {
+		for (let key in source) target[key] = source[key];
+	});
+	return target;
+}
+function basename(path) {
+	const idx = ~path.lastIndexOf("/") || ~path.lastIndexOf("\\");
+	if (idx === 0) return path;
+	else if (~idx === path.length - 1) return basename(path.substring(0, path.length - 1));
+	else return path.substr(~idx + 1);
+}
+var CAPTURING_REGEX_SOURCE = /\$(\d+)|\${(\d+):\/(downcase|upcase)}/g;
+var RegexSource = class {
+	static hasCaptures(regexSource) {
+		if (regexSource === null) return false;
+		CAPTURING_REGEX_SOURCE.lastIndex = 0;
+		return CAPTURING_REGEX_SOURCE.test(regexSource);
+	}
+	static replaceCaptures(regexSource, captureSource, captureIndices) {
+		return regexSource.replace(CAPTURING_REGEX_SOURCE, (match, index, commandIndex, command) => {
+			let capture = captureIndices[parseInt(index || commandIndex, 10)];
+			if (capture) {
+				let result = captureSource.substring(capture.start, capture.end);
+				while (result[0] === ".") result = result.substring(1);
+				switch (command) {
+					case "downcase": return result.toLowerCase();
+					case "upcase": return result.toUpperCase();
+					default: return result;
+				}
+			} else return match;
+		});
+	}
+};
+function strcmp(a, b) {
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+function strArrCmp(a, b) {
+	if (a === null && b === null) return 0;
+	if (!a) return -1;
+	if (!b) return 1;
+	let len1 = a.length;
+	let len2 = b.length;
+	if (len1 === len2) {
+		for (let i = 0; i < len1; i++) {
+			let res = strcmp(a[i], b[i]);
+			if (res !== 0) return res;
+		}
+		return 0;
+	}
+	return len1 - len2;
+}
+function isValidHexColor(hex) {
+	if (/^#[0-9a-f]{6}$/i.test(hex)) return true;
+	if (/^#[0-9a-f]{8}$/i.test(hex)) return true;
+	if (/^#[0-9a-f]{3}$/i.test(hex)) return true;
+	if (/^#[0-9a-f]{4}$/i.test(hex)) return true;
+	return false;
+}
+function escapeRegExpCharacters(value) {
+	return value.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, "\\$&");
+}
+var CachedFn = class {
+	constructor(fn) {
+		this.fn = fn;
+	}
+	cache = /* @__PURE__ */ new Map();
+	get(key) {
+		if (this.cache.has(key)) return this.cache.get(key);
+		const value = this.fn(key);
+		this.cache.set(key, value);
+		return value;
+	}
+};
+var Theme = class {
+	constructor(_colorMap, _defaults, _root) {
+		this._colorMap = _colorMap;
+		this._defaults = _defaults;
+		this._root = _root;
+	}
+	static createFromRawTheme(source, colorMap) {
+		return this.createFromParsedTheme(parseTheme(source), colorMap);
+	}
+	static createFromParsedTheme(source, colorMap) {
+		return resolveParsedThemeRules(source, colorMap);
+	}
+	_cachedMatchRoot = new CachedFn((scopeName) => this._root.match(scopeName));
+	getColorMap() {
+		return this._colorMap.getColorMap();
+	}
+	getDefaults() {
+		return this._defaults;
+	}
+	match(scopePath) {
+		if (scopePath === null) return this._defaults;
+		const scopeName = scopePath.scopeName;
+		const effectiveRule = this._cachedMatchRoot.get(scopeName).find((v) => _scopePathMatchesParentScopes(scopePath.parent, v.parentScopes));
+		if (!effectiveRule) return null;
+		return new StyleAttributes(effectiveRule.fontStyle, effectiveRule.foreground, effectiveRule.background);
+	}
+};
+var ScopeStack = class _ScopeStack {
+	constructor(parent, scopeName) {
+		this.parent = parent;
+		this.scopeName = scopeName;
+	}
+	static push(path, scopeNames) {
+		for (const name of scopeNames) path = new _ScopeStack(path, name);
+		return path;
+	}
+	static from(...segments) {
+		let result = null;
+		for (let i = 0; i < segments.length; i++) result = new _ScopeStack(result, segments[i]);
+		return result;
+	}
+	push(scopeName) {
+		return new _ScopeStack(this, scopeName);
+	}
+	getSegments() {
+		let item = this;
+		const result = [];
+		while (item) {
+			result.push(item.scopeName);
+			item = item.parent;
+		}
+		result.reverse();
+		return result;
+	}
+	toString() {
+		return this.getSegments().join(" ");
+	}
+	extends(other) {
+		if (this === other) return true;
+		if (this.parent === null) return false;
+		return this.parent.extends(other);
+	}
+	getExtensionIfDefined(base) {
+		const result = [];
+		let item = this;
+		while (item && item !== base) {
+			result.push(item.scopeName);
+			item = item.parent;
+		}
+		return item === base ? result.reverse() : void 0;
+	}
+};
+function _scopePathMatchesParentScopes(scopePath, parentScopes) {
+	if (parentScopes.length === 0) return true;
+	for (let index = 0; index < parentScopes.length; index++) {
+		let scopePattern = parentScopes[index];
+		let scopeMustMatch = false;
+		if (scopePattern === ">") {
+			if (index === parentScopes.length - 1) return false;
+			scopePattern = parentScopes[++index];
+			scopeMustMatch = true;
+		}
+		while (scopePath) {
+			if (_matchesScope(scopePath.scopeName, scopePattern)) break;
+			if (scopeMustMatch) return false;
+			scopePath = scopePath.parent;
+		}
+		if (!scopePath) return false;
+		scopePath = scopePath.parent;
+	}
+	return true;
+}
+function _matchesScope(scopeName, scopePattern) {
+	return scopePattern === scopeName || scopeName.startsWith(scopePattern) && scopeName[scopePattern.length] === ".";
+}
+var StyleAttributes = class {
+	constructor(fontStyle, foregroundId, backgroundId) {
+		this.fontStyle = fontStyle;
+		this.foregroundId = foregroundId;
+		this.backgroundId = backgroundId;
+	}
+};
+function parseTheme(source) {
+	if (!source) return [];
+	if (!source.settings || !Array.isArray(source.settings)) return [];
+	let settings = source.settings;
+	let result = [], resultLen = 0;
+	for (let i = 0, len = settings.length; i < len; i++) {
+		let entry = settings[i];
+		if (!entry.settings) continue;
+		let scopes;
+		if (typeof entry.scope === "string") {
+			let _scope = entry.scope;
+			_scope = _scope.replace(/^[,]+/, "");
+			_scope = _scope.replace(/[,]+$/, "");
+			scopes = _scope.split(",");
+		} else if (Array.isArray(entry.scope)) scopes = entry.scope;
+		else scopes = [""];
+		let fontStyle = -1;
+		if (typeof entry.settings.fontStyle === "string") {
+			fontStyle = 0;
+			let segments = entry.settings.fontStyle.split(" ");
+			for (let j = 0, lenJ = segments.length; j < lenJ; j++) switch (segments[j]) {
+				case "italic":
+					fontStyle = fontStyle | 1;
+					break;
+				case "bold":
+					fontStyle = fontStyle | 2;
+					break;
+				case "underline":
+					fontStyle = fontStyle | 4;
+					break;
+				case "strikethrough": fontStyle = fontStyle | 8;
+			}
+		}
+		let foreground = null;
+		if (typeof entry.settings.foreground === "string" && isValidHexColor(entry.settings.foreground)) foreground = entry.settings.foreground;
+		let background = null;
+		if (typeof entry.settings.background === "string" && isValidHexColor(entry.settings.background)) background = entry.settings.background;
+		for (let j = 0, lenJ = scopes.length; j < lenJ; j++) {
+			let segments = scopes[j].trim().split(" ");
+			let scope = segments[segments.length - 1];
+			let parentScopes = null;
+			if (segments.length > 1) {
+				parentScopes = segments.slice(0, segments.length - 1);
+				parentScopes.reverse();
+			}
+			result[resultLen++] = new ParsedThemeRule(scope, parentScopes, i, fontStyle, foreground, background);
+		}
+	}
+	return result;
+}
+var ParsedThemeRule = class {
+	constructor(scope, parentScopes, index, fontStyle, foreground, background) {
+		this.scope = scope;
+		this.parentScopes = parentScopes;
+		this.index = index;
+		this.fontStyle = fontStyle;
+		this.foreground = foreground;
+		this.background = background;
+	}
+};
+var FontStyle = /* @__PURE__ */ ((FontStyle2) => {
+	FontStyle2[FontStyle2["NotSet"] = -1] = "NotSet";
+	FontStyle2[FontStyle2["None"] = 0] = "None";
+	FontStyle2[FontStyle2["Italic"] = 1] = "Italic";
+	FontStyle2[FontStyle2["Bold"] = 2] = "Bold";
+	FontStyle2[FontStyle2["Underline"] = 4] = "Underline";
+	FontStyle2[FontStyle2["Strikethrough"] = 8] = "Strikethrough";
+	return FontStyle2;
+})(FontStyle || {});
+function resolveParsedThemeRules(parsedThemeRules, _colorMap) {
+	parsedThemeRules.sort((a, b) => {
+		let r = strcmp(a.scope, b.scope);
+		if (r !== 0) return r;
+		r = strArrCmp(a.parentScopes, b.parentScopes);
+		if (r !== 0) return r;
+		return a.index - b.index;
+	});
+	let defaultFontStyle = 0;
+	let defaultForeground = "#000000";
+	let defaultBackground = "#ffffff";
+	while (parsedThemeRules.length >= 1 && parsedThemeRules[0].scope === "") {
+		let incomingDefaults = parsedThemeRules.shift();
+		if (incomingDefaults.fontStyle !== -1) defaultFontStyle = incomingDefaults.fontStyle;
+		if (incomingDefaults.foreground !== null) defaultForeground = incomingDefaults.foreground;
+		if (incomingDefaults.background !== null) defaultBackground = incomingDefaults.background;
+	}
+	let colorMap = new ColorMap(_colorMap);
+	let defaults = new StyleAttributes(defaultFontStyle, colorMap.getId(defaultForeground), colorMap.getId(defaultBackground));
+	let root = new ThemeTrieElement(new ThemeTrieElementRule(0, null, -1, 0, 0), []);
+	for (let i = 0, len = parsedThemeRules.length; i < len; i++) {
+		let rule = parsedThemeRules[i];
+		root.insert(0, rule.scope, rule.parentScopes, rule.fontStyle, colorMap.getId(rule.foreground), colorMap.getId(rule.background));
+	}
+	return new Theme(colorMap, defaults, root);
+}
+var ColorMap = class {
+	_isFrozen;
+	_lastColorId;
+	_id2color;
+	_color2id;
+	constructor(_colorMap) {
+		this._lastColorId = 0;
+		this._id2color = [];
+		this._color2id = /* @__PURE__ */ Object.create(null);
+		if (Array.isArray(_colorMap)) {
+			this._isFrozen = true;
+			for (let i = 0, len = _colorMap.length; i < len; i++) {
+				this._color2id[_colorMap[i]] = i;
+				this._id2color[i] = _colorMap[i];
+			}
+		} else this._isFrozen = false;
+	}
+	getId(color) {
+		if (color === null) return 0;
+		color = color.toUpperCase();
+		let value = this._color2id[color];
+		if (value) return value;
+		if (this._isFrozen) throw new Error(`Missing color in color map - ${color}`);
+		value = ++this._lastColorId;
+		this._color2id[color] = value;
+		this._id2color[value] = color;
+		return value;
+	}
+	getColorMap() {
+		return this._id2color.slice(0);
+	}
+};
+var emptyParentScopes = Object.freeze([]);
+var ThemeTrieElementRule = class _ThemeTrieElementRule {
+	scopeDepth;
+	parentScopes;
+	fontStyle;
+	foreground;
+	background;
+	constructor(scopeDepth, parentScopes, fontStyle, foreground, background) {
+		this.scopeDepth = scopeDepth;
+		this.parentScopes = parentScopes || emptyParentScopes;
+		this.fontStyle = fontStyle;
+		this.foreground = foreground;
+		this.background = background;
+	}
+	clone() {
+		return new _ThemeTrieElementRule(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);
+	}
+	static cloneArr(arr) {
+		let r = [];
+		for (let i = 0, len = arr.length; i < len; i++) r[i] = arr[i].clone();
+		return r;
+	}
+	acceptOverwrite(scopeDepth, fontStyle, foreground, background) {
+		if (this.scopeDepth > scopeDepth) console.log("how did this happen?");
+		else this.scopeDepth = scopeDepth;
+		if (fontStyle !== -1) this.fontStyle = fontStyle;
+		if (foreground !== 0) this.foreground = foreground;
+		if (background !== 0) this.background = background;
+	}
+};
+var ThemeTrieElement = class _ThemeTrieElement {
+	constructor(_mainRule, rulesWithParentScopes = [], _children = {}) {
+		this._mainRule = _mainRule;
+		this._children = _children;
+		this._rulesWithParentScopes = rulesWithParentScopes;
+	}
+	_rulesWithParentScopes;
+	static _cmpBySpecificity(a, b) {
+		if (a.scopeDepth !== b.scopeDepth) return b.scopeDepth - a.scopeDepth;
+		let aParentIndex = 0;
+		let bParentIndex = 0;
+		while (true) {
+			if (a.parentScopes[aParentIndex] === ">") aParentIndex++;
+			if (b.parentScopes[bParentIndex] === ">") bParentIndex++;
+			if (aParentIndex >= a.parentScopes.length || bParentIndex >= b.parentScopes.length) break;
+			const parentScopeLengthDiff = b.parentScopes[bParentIndex].length - a.parentScopes[aParentIndex].length;
+			if (parentScopeLengthDiff !== 0) return parentScopeLengthDiff;
+			aParentIndex++;
+			bParentIndex++;
+		}
+		return b.parentScopes.length - a.parentScopes.length;
+	}
+	match(scope) {
+		if (scope !== "") {
+			let dotIndex = scope.indexOf(".");
+			let head;
+			let tail;
+			if (dotIndex === -1) {
+				head = scope;
+				tail = "";
+			} else {
+				head = scope.substring(0, dotIndex);
+				tail = scope.substring(dotIndex + 1);
+			}
+			if (this._children.hasOwnProperty(head)) return this._children[head].match(tail);
+		}
+		const rules = this._rulesWithParentScopes.concat(this._mainRule);
+		rules.sort(_ThemeTrieElement._cmpBySpecificity);
+		return rules;
+	}
+	insert(scopeDepth, scope, parentScopes, fontStyle, foreground, background) {
+		if (scope === "") {
+			this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);
+			return;
+		}
+		let dotIndex = scope.indexOf(".");
+		let head;
+		let tail;
+		if (dotIndex === -1) {
+			head = scope;
+			tail = "";
+		} else {
+			head = scope.substring(0, dotIndex);
+			tail = scope.substring(dotIndex + 1);
+		}
+		let child;
+		if (this._children.hasOwnProperty(head)) child = this._children[head];
+		else {
+			child = new _ThemeTrieElement(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));
+			this._children[head] = child;
+		}
+		child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);
+	}
+	_doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background) {
+		if (parentScopes === null) {
+			this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
+			return;
+		}
+		for (let i = 0, len = this._rulesWithParentScopes.length; i < len; i++) {
+			let rule = this._rulesWithParentScopes[i];
+			if (strArrCmp(rule.parentScopes, parentScopes) === 0) {
+				rule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
+				return;
+			}
+		}
+		if (fontStyle === -1) fontStyle = this._mainRule.fontStyle;
+		if (foreground === 0) foreground = this._mainRule.foreground;
+		if (background === 0) background = this._mainRule.background;
+		this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle, foreground, background));
+	}
+};
+var EncodedTokenMetadata = class _EncodedTokenMetadata {
+	static toBinaryStr(encodedTokenAttributes) {
+		return encodedTokenAttributes.toString(2).padStart(32, "0");
+	}
+	static print(encodedTokenAttributes) {
+		const languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);
+		const tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);
+		const fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);
+		const foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);
+		const background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);
+		console.log({
+			languageId,
+			tokenType,
+			fontStyle,
+			foreground,
+			background
+		});
+	}
+	static getLanguageId(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 255) >>> 0;
+	}
+	static getTokenType(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 768) >>> 8;
+	}
+	static containsBalancedBrackets(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 1024) !== 0;
+	}
+	static getFontStyle(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 30720) >>> 11;
+	}
+	static getForeground(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 16744448) >>> 15;
+	}
+	static getBackground(encodedTokenAttributes) {
+		return (encodedTokenAttributes & 4278190080) >>> 24;
+	}
+	/**
+	* Updates the fields in `metadata`.
+	* A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.
+	*/
+	static set(encodedTokenAttributes, languageId, tokenType, containsBalancedBrackets, fontStyle, foreground, background) {
+		let _languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);
+		let _tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);
+		let _containsBalancedBracketsBit = _EncodedTokenMetadata.containsBalancedBrackets(encodedTokenAttributes) ? 1 : 0;
+		let _fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);
+		let _foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);
+		let _background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);
+		if (languageId !== 0) _languageId = languageId;
+		if (tokenType !== 8) _tokenType = fromOptionalTokenType(tokenType);
+		if (containsBalancedBrackets !== null) _containsBalancedBracketsBit = containsBalancedBrackets ? 1 : 0;
+		if (fontStyle !== -1) _fontStyle = fontStyle;
+		if (foreground !== 0) _foreground = foreground;
+		if (background !== 0) _background = background;
+		return (_languageId << 0 | _tokenType << 8 | _containsBalancedBracketsBit << 10 | _fontStyle << 11 | _foreground << 15 | _background << 24) >>> 0;
+	}
+};
+function toOptionalTokenType(standardType) {
+	return standardType;
+}
+function fromOptionalTokenType(standardType) {
+	return standardType;
+}
+function createMatchers(selector, matchesName) {
+	const results = [];
+	const tokenizer = newTokenizer(selector);
+	let token = tokenizer.next();
+	while (token !== null) {
+		let priority = 0;
+		if (token.length === 2 && token.charAt(1) === ":") {
+			switch (token.charAt(0)) {
+				case "R":
+					priority = 1;
+					break;
+				case "L":
+					priority = -1;
+					break;
+				default: console.log(`Unknown priority ${token} in scope selector`);
+			}
+			token = tokenizer.next();
+		}
+		let matcher = parseConjunction();
+		results.push({
+			matcher,
+			priority
+		});
+		if (token !== ",") break;
+		token = tokenizer.next();
+	}
+	return results;
+	function parseOperand() {
+		if (token === "-") {
+			token = tokenizer.next();
+			const expressionToNegate = parseOperand();
+			return (matcherInput) => !!expressionToNegate && !expressionToNegate(matcherInput);
+		}
+		if (token === "(") {
+			token = tokenizer.next();
+			const expressionInParents = parseInnerExpression();
+			if (token === ")") token = tokenizer.next();
+			return expressionInParents;
+		}
+		if (isIdentifier(token)) {
+			const identifiers = [];
+			do {
+				identifiers.push(token);
+				token = tokenizer.next();
+			} while (isIdentifier(token));
+			return (matcherInput) => matchesName(identifiers, matcherInput);
+		}
+		return null;
+	}
+	function parseConjunction() {
+		const matchers = [];
+		let matcher = parseOperand();
+		while (matcher) {
+			matchers.push(matcher);
+			matcher = parseOperand();
+		}
+		return (matcherInput) => matchers.every((matcher2) => matcher2(matcherInput));
+	}
+	function parseInnerExpression() {
+		const matchers = [];
+		let matcher = parseConjunction();
+		while (matcher) {
+			matchers.push(matcher);
+			if (token === "|" || token === ",") do
+				token = tokenizer.next();
+			while (token === "|" || token === ",");
+			else break;
+			matcher = parseConjunction();
+		}
+		return (matcherInput) => matchers.some((matcher2) => matcher2(matcherInput));
+	}
+}
+function isIdentifier(token) {
+	return !!token && !!token.match(/[\w\.:]+/);
+}
+function newTokenizer(input) {
+	let regex = /([LR]:|[\w\.:][\w\.:\-]*|[\,\|\-\(\)])/g;
+	let match = regex.exec(input);
+	return { next: () => {
+		if (!match) return null;
+		const res = match[0];
+		match = regex.exec(input);
+		return res;
+	} };
+}
+function disposeOnigString(str) {
+	if (typeof str.dispose === "function") str.dispose();
+}
+var TopLevelRuleReference = class {
+	constructor(scopeName) {
+		this.scopeName = scopeName;
+	}
+	toKey() {
+		return this.scopeName;
+	}
+};
+var TopLevelRepositoryRuleReference = class {
+	constructor(scopeName, ruleName) {
+		this.scopeName = scopeName;
+		this.ruleName = ruleName;
+	}
+	toKey() {
+		return `${this.scopeName}#${this.ruleName}`;
+	}
+};
+var ExternalReferenceCollector = class {
+	_references = [];
+	_seenReferenceKeys = /* @__PURE__ */ new Set();
+	get references() {
+		return this._references;
+	}
+	visitedRule = /* @__PURE__ */ new Set();
+	add(reference) {
+		const key = reference.toKey();
+		if (this._seenReferenceKeys.has(key)) return;
+		this._seenReferenceKeys.add(key);
+		this._references.push(reference);
+	}
+};
+var ScopeDependencyProcessor = class {
+	constructor(repo, initialScopeName) {
+		this.repo = repo;
+		this.initialScopeName = initialScopeName;
+		this.seenFullScopeRequests.add(this.initialScopeName);
+		this.Q = [new TopLevelRuleReference(this.initialScopeName)];
+	}
+	seenFullScopeRequests = /* @__PURE__ */ new Set();
+	seenPartialScopeRequests = /* @__PURE__ */ new Set();
+	Q;
+	processQueue() {
+		const q = this.Q;
+		this.Q = [];
+		const deps = new ExternalReferenceCollector();
+		for (const dep of q) collectReferencesOfReference(dep, this.initialScopeName, this.repo, deps);
+		for (const dep of deps.references) if (dep instanceof TopLevelRuleReference) {
+			if (this.seenFullScopeRequests.has(dep.scopeName)) continue;
+			this.seenFullScopeRequests.add(dep.scopeName);
+			this.Q.push(dep);
+		} else {
+			if (this.seenFullScopeRequests.has(dep.scopeName)) continue;
+			if (this.seenPartialScopeRequests.has(dep.toKey())) continue;
+			this.seenPartialScopeRequests.add(dep.toKey());
+			this.Q.push(dep);
+		}
+	}
+};
+function collectReferencesOfReference(reference, baseGrammarScopeName, repo, result) {
+	const selfGrammar = repo.lookup(reference.scopeName);
+	if (!selfGrammar) {
+		if (reference.scopeName === baseGrammarScopeName) throw new Error(`No grammar provided for <${baseGrammarScopeName}>`);
+		return;
+	}
+	const baseGrammar = repo.lookup(baseGrammarScopeName);
+	if (reference instanceof TopLevelRuleReference) collectExternalReferencesInTopLevelRule({
+		baseGrammar,
+		selfGrammar
+	}, result);
+	else collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, {
+		baseGrammar,
+		selfGrammar,
+		repository: selfGrammar.repository
+	}, result);
+	const injections = repo.injections(reference.scopeName);
+	if (injections) for (const injection of injections) result.add(new TopLevelRuleReference(injection));
+}
+function collectExternalReferencesInTopLevelRepositoryRule(ruleName, context, result) {
+	if (context.repository && context.repository[ruleName]) {
+		const rule = context.repository[ruleName];
+		collectExternalReferencesInRules([rule], context, result);
+	}
+}
+function collectExternalReferencesInTopLevelRule(context, result) {
+	if (context.selfGrammar.patterns && Array.isArray(context.selfGrammar.patterns)) collectExternalReferencesInRules(context.selfGrammar.patterns, {
+		...context,
+		repository: context.selfGrammar.repository
+	}, result);
+	if (context.selfGrammar.injections) collectExternalReferencesInRules(Object.values(context.selfGrammar.injections), {
+		...context,
+		repository: context.selfGrammar.repository
+	}, result);
+}
+function collectExternalReferencesInRules(rules, context, result) {
+	for (const rule of rules) {
+		if (result.visitedRule.has(rule)) continue;
+		result.visitedRule.add(rule);
+		const patternRepository = rule.repository ? mergeObjects({}, context.repository, rule.repository) : context.repository;
+		if (Array.isArray(rule.patterns)) collectExternalReferencesInRules(rule.patterns, {
+			...context,
+			repository: patternRepository
+		}, result);
+		const include = rule.include;
+		if (!include) continue;
+		const reference = parseInclude(include);
+		switch (reference.kind) {
+			case 0:
+				collectExternalReferencesInTopLevelRule({
+					...context,
+					selfGrammar: context.baseGrammar
+				}, result);
+				break;
+			case 1:
+				collectExternalReferencesInTopLevelRule(context, result);
+				break;
+			case 2:
+				collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, {
+					...context,
+					repository: patternRepository
+				}, result);
+				break;
+			case 3:
+			case 4:
+				const selfGrammar = reference.scopeName === context.selfGrammar.scopeName ? context.selfGrammar : reference.scopeName === context.baseGrammar.scopeName ? context.baseGrammar : void 0;
+				if (selfGrammar) {
+					const newContext = {
+						baseGrammar: context.baseGrammar,
+						selfGrammar,
+						repository: patternRepository
+					};
+					if (reference.kind === 4) collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, newContext, result);
+					else collectExternalReferencesInTopLevelRule(newContext, result);
+				} else if (reference.kind === 4) result.add(new TopLevelRepositoryRuleReference(reference.scopeName, reference.ruleName));
+				else result.add(new TopLevelRuleReference(reference.scopeName));
+		}
+	}
+}
+var BaseReference = class {
+	kind = 0;
+};
+var SelfReference = class {
+	kind = 1;
+};
+var RelativeReference = class {
+	constructor(ruleName) {
+		this.ruleName = ruleName;
+	}
+	kind = 2;
+};
+var TopLevelReference = class {
+	constructor(scopeName) {
+		this.scopeName = scopeName;
+	}
+	kind = 3;
+};
+var TopLevelRepositoryReference = class {
+	constructor(scopeName, ruleName) {
+		this.scopeName = scopeName;
+		this.ruleName = ruleName;
+	}
+	kind = 4;
+};
+function parseInclude(include) {
+	if (include === "$base") return new BaseReference();
+	else if (include === "$self") return new SelfReference();
+	const indexOfSharp = include.indexOf("#");
+	if (indexOfSharp === -1) return new TopLevelReference(include);
+	else if (indexOfSharp === 0) return new RelativeReference(include.substring(1));
+	else return new TopLevelRepositoryReference(include.substring(0, indexOfSharp), include.substring(indexOfSharp + 1));
+}
+var HAS_BACK_REFERENCES = /\\(\d+)/;
+var BACK_REFERENCING_END = /\\(\d+)/g;
+var endRuleId = -1;
+var whileRuleId = -2;
+function ruleIdFromNumber(id) {
+	return id;
+}
+function ruleIdToNumber(id) {
+	return id;
+}
+var Rule = class {
+	$location;
+	id;
+	_nameIsCapturing;
+	_name;
+	_contentNameIsCapturing;
+	_contentName;
+	constructor($location, id, name, contentName) {
+		this.$location = $location;
+		this.id = id;
+		this._name = name || null;
+		this._nameIsCapturing = RegexSource.hasCaptures(this._name);
+		this._contentName = contentName || null;
+		this._contentNameIsCapturing = RegexSource.hasCaptures(this._contentName);
+	}
+	get debugName() {
+		const location = this.$location ? `${basename(this.$location.filename)}:${this.$location.line}` : "unknown";
+		return `${this.constructor.name}#${this.id} @ ${location}`;
+	}
+	getName(lineText, captureIndices) {
+		if (!this._nameIsCapturing || this._name === null || lineText === null || captureIndices === null) return this._name;
+		return RegexSource.replaceCaptures(this._name, lineText, captureIndices);
+	}
+	getContentName(lineText, captureIndices) {
+		if (!this._contentNameIsCapturing || this._contentName === null) return this._contentName;
+		return RegexSource.replaceCaptures(this._contentName, lineText, captureIndices);
+	}
+};
+var CaptureRule = class extends Rule {
+	retokenizeCapturedWithRuleId;
+	constructor($location, id, name, contentName, retokenizeCapturedWithRuleId) {
+		super($location, id, name, contentName);
+		this.retokenizeCapturedWithRuleId = retokenizeCapturedWithRuleId;
+	}
+	dispose() {}
+	collectPatterns(grammar, out) {
+		throw new Error("Not supported!");
+	}
+	compile(grammar, endRegexSource) {
+		throw new Error("Not supported!");
+	}
+	compileAG(grammar, endRegexSource, allowA, allowG) {
+		throw new Error("Not supported!");
+	}
+};
+var MatchRule = class extends Rule {
+	_match;
+	captures;
+	_cachedCompiledPatterns;
+	constructor($location, id, name, match, captures) {
+		super($location, id, name, null);
+		this._match = new RegExpSource(match, this.id);
+		this.captures = captures;
+		this._cachedCompiledPatterns = null;
+	}
+	dispose() {
+		if (this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns.dispose();
+			this._cachedCompiledPatterns = null;
+		}
+	}
+	get debugMatchRegExp() {
+		return `${this._match.source}`;
+	}
+	collectPatterns(grammar, out) {
+		out.push(this._match);
+	}
+	compile(grammar, endRegexSource) {
+		return this._getCachedCompiledPatterns(grammar).compile(grammar);
+	}
+	compileAG(grammar, endRegexSource, allowA, allowG) {
+		return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
+	}
+	_getCachedCompiledPatterns(grammar) {
+		if (!this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns = new RegExpSourceList();
+			this.collectPatterns(grammar, this._cachedCompiledPatterns);
+		}
+		return this._cachedCompiledPatterns;
+	}
+};
+var IncludeOnlyRule = class extends Rule {
+	hasMissingPatterns;
+	patterns;
+	_cachedCompiledPatterns;
+	constructor($location, id, name, contentName, patterns) {
+		super($location, id, name, contentName);
+		this.patterns = patterns.patterns;
+		this.hasMissingPatterns = patterns.hasMissingPatterns;
+		this._cachedCompiledPatterns = null;
+	}
+	dispose() {
+		if (this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns.dispose();
+			this._cachedCompiledPatterns = null;
+		}
+	}
+	collectPatterns(grammar, out) {
+		for (const pattern of this.patterns) grammar.getRule(pattern).collectPatterns(grammar, out);
+	}
+	compile(grammar, endRegexSource) {
+		return this._getCachedCompiledPatterns(grammar).compile(grammar);
+	}
+	compileAG(grammar, endRegexSource, allowA, allowG) {
+		return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
+	}
+	_getCachedCompiledPatterns(grammar) {
+		if (!this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns = new RegExpSourceList();
+			this.collectPatterns(grammar, this._cachedCompiledPatterns);
+		}
+		return this._cachedCompiledPatterns;
+	}
+};
+var BeginEndRule = class extends Rule {
+	_begin;
+	beginCaptures;
+	_end;
+	endHasBackReferences;
+	endCaptures;
+	applyEndPatternLast;
+	hasMissingPatterns;
+	patterns;
+	_cachedCompiledPatterns;
+	constructor($location, id, name, contentName, begin, beginCaptures, end, endCaptures, applyEndPatternLast, patterns) {
+		super($location, id, name, contentName);
+		this._begin = new RegExpSource(begin, this.id);
+		this.beginCaptures = beginCaptures;
+		this._end = new RegExpSource(end ? end : "￿", -1);
+		this.endHasBackReferences = this._end.hasBackReferences;
+		this.endCaptures = endCaptures;
+		this.applyEndPatternLast = applyEndPatternLast || false;
+		this.patterns = patterns.patterns;
+		this.hasMissingPatterns = patterns.hasMissingPatterns;
+		this._cachedCompiledPatterns = null;
+	}
+	dispose() {
+		if (this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns.dispose();
+			this._cachedCompiledPatterns = null;
+		}
+	}
+	get debugBeginRegExp() {
+		return `${this._begin.source}`;
+	}
+	get debugEndRegExp() {
+		return `${this._end.source}`;
+	}
+	getEndWithResolvedBackReferences(lineText, captureIndices) {
+		return this._end.resolveBackReferences(lineText, captureIndices);
+	}
+	collectPatterns(grammar, out) {
+		out.push(this._begin);
+	}
+	compile(grammar, endRegexSource) {
+		return this._getCachedCompiledPatterns(grammar, endRegexSource).compile(grammar);
+	}
+	compileAG(grammar, endRegexSource, allowA, allowG) {
+		return this._getCachedCompiledPatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);
+	}
+	_getCachedCompiledPatterns(grammar, endRegexSource) {
+		if (!this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns = new RegExpSourceList();
+			for (const pattern of this.patterns) grammar.getRule(pattern).collectPatterns(grammar, this._cachedCompiledPatterns);
+			if (this.applyEndPatternLast) this._cachedCompiledPatterns.push(this._end.hasBackReferences ? this._end.clone() : this._end);
+			else this._cachedCompiledPatterns.unshift(this._end.hasBackReferences ? this._end.clone() : this._end);
+		}
+		if (this._end.hasBackReferences) {
+			if (this.applyEndPatternLast) this._cachedCompiledPatterns.setSource(this._cachedCompiledPatterns.length() - 1, endRegexSource);
+			else this._cachedCompiledPatterns.setSource(0, endRegexSource);
+		}
+		return this._cachedCompiledPatterns;
+	}
+};
+var BeginWhileRule = class extends Rule {
+	_begin;
+	beginCaptures;
+	whileCaptures;
+	_while;
+	whileHasBackReferences;
+	hasMissingPatterns;
+	patterns;
+	_cachedCompiledPatterns;
+	_cachedCompiledWhilePatterns;
+	constructor($location, id, name, contentName, begin, beginCaptures, _while, whileCaptures, patterns) {
+		super($location, id, name, contentName);
+		this._begin = new RegExpSource(begin, this.id);
+		this.beginCaptures = beginCaptures;
+		this.whileCaptures = whileCaptures;
+		this._while = new RegExpSource(_while, whileRuleId);
+		this.whileHasBackReferences = this._while.hasBackReferences;
+		this.patterns = patterns.patterns;
+		this.hasMissingPatterns = patterns.hasMissingPatterns;
+		this._cachedCompiledPatterns = null;
+		this._cachedCompiledWhilePatterns = null;
+	}
+	dispose() {
+		if (this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns.dispose();
+			this._cachedCompiledPatterns = null;
+		}
+		if (this._cachedCompiledWhilePatterns) {
+			this._cachedCompiledWhilePatterns.dispose();
+			this._cachedCompiledWhilePatterns = null;
+		}
+	}
+	get debugBeginRegExp() {
+		return `${this._begin.source}`;
+	}
+	get debugWhileRegExp() {
+		return `${this._while.source}`;
+	}
+	getWhileWithResolvedBackReferences(lineText, captureIndices) {
+		return this._while.resolveBackReferences(lineText, captureIndices);
+	}
+	collectPatterns(grammar, out) {
+		out.push(this._begin);
+	}
+	compile(grammar, endRegexSource) {
+		return this._getCachedCompiledPatterns(grammar).compile(grammar);
+	}
+	compileAG(grammar, endRegexSource, allowA, allowG) {
+		return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
+	}
+	_getCachedCompiledPatterns(grammar) {
+		if (!this._cachedCompiledPatterns) {
+			this._cachedCompiledPatterns = new RegExpSourceList();
+			for (const pattern of this.patterns) grammar.getRule(pattern).collectPatterns(grammar, this._cachedCompiledPatterns);
+		}
+		return this._cachedCompiledPatterns;
+	}
+	compileWhile(grammar, endRegexSource) {
+		return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compile(grammar);
+	}
+	compileWhileAG(grammar, endRegexSource, allowA, allowG) {
+		return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);
+	}
+	_getCachedCompiledWhilePatterns(grammar, endRegexSource) {
+		if (!this._cachedCompiledWhilePatterns) {
+			this._cachedCompiledWhilePatterns = new RegExpSourceList();
+			this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while);
+		}
+		if (this._while.hasBackReferences) this._cachedCompiledWhilePatterns.setSource(0, endRegexSource ? endRegexSource : "￿");
+		return this._cachedCompiledWhilePatterns;
+	}
+};
+var RuleFactory = class _RuleFactory {
+	static createCaptureRule(helper, $location, name, contentName, retokenizeCapturedWithRuleId) {
+		return helper.registerRule((id) => {
+			return new CaptureRule($location, id, name, contentName, retokenizeCapturedWithRuleId);
+		});
+	}
+	static getCompiledRuleId(desc, helper, repository) {
+		if (!desc.id) helper.registerRule((id) => {
+			desc.id = id;
+			if (desc.match) return new MatchRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.match, _RuleFactory._compileCaptures(desc.captures, helper, repository));
+			if (typeof desc.begin === "undefined") {
+				if (desc.repository) repository = mergeObjects({}, repository, desc.repository);
+				let patterns = desc.patterns;
+				if (typeof patterns === "undefined" && desc.include) patterns = [{ include: desc.include }];
+				return new IncludeOnlyRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, _RuleFactory._compilePatterns(patterns, helper, repository));
+			}
+			if (desc.while) return new BeginWhileRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, desc.begin, _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository), desc.while, _RuleFactory._compileCaptures(desc.whileCaptures || desc.captures, helper, repository), _RuleFactory._compilePatterns(desc.patterns, helper, repository));
+			return new BeginEndRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, desc.begin, _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository), desc.end, _RuleFactory._compileCaptures(desc.endCaptures || desc.captures, helper, repository), desc.applyEndPatternLast, _RuleFactory._compilePatterns(desc.patterns, helper, repository));
+		});
+		return desc.id;
+	}
+	static _compileCaptures(captures, helper, repository) {
+		let r = [];
+		if (captures) {
+			let maximumCaptureId = 0;
+			for (const captureId in captures) {
+				if (captureId === "$vscodeTextmateLocation") continue;
+				const numericCaptureId = parseInt(captureId, 10);
+				if (numericCaptureId > maximumCaptureId) maximumCaptureId = numericCaptureId;
+			}
+			for (let i = 0; i <= maximumCaptureId; i++) r[i] = null;
+			for (const captureId in captures) {
+				if (captureId === "$vscodeTextmateLocation") continue;
+				const numericCaptureId = parseInt(captureId, 10);
+				let retokenizeCapturedWithRuleId = 0;
+				if (captures[captureId].patterns) retokenizeCapturedWithRuleId = _RuleFactory.getCompiledRuleId(captures[captureId], helper, repository);
+				r[numericCaptureId] = _RuleFactory.createCaptureRule(helper, captures[captureId].$vscodeTextmateLocation, captures[captureId].name, captures[captureId].contentName, retokenizeCapturedWithRuleId);
+			}
+		}
+		return r;
+	}
+	static _compilePatterns(patterns, helper, repository) {
+		let r = [];
+		if (patterns) for (let i = 0, len = patterns.length; i < len; i++) {
+			const pattern = patterns[i];
+			let ruleId = -1;
+			if (pattern.include) {
+				const reference = parseInclude(pattern.include);
+				switch (reference.kind) {
+					case 0:
+					case 1:
+						ruleId = _RuleFactory.getCompiledRuleId(repository[pattern.include], helper, repository);
+						break;
+					case 2:
+						let localIncludedRule = repository[reference.ruleName];
+						if (localIncludedRule) ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);
+						break;
+					case 3:
+					case 4:
+						const externalGrammarName = reference.scopeName;
+						const externalGrammarInclude = reference.kind === 4 ? reference.ruleName : null;
+						const externalGrammar = helper.getExternalGrammar(externalGrammarName, repository);
+						if (externalGrammar) {
+							if (externalGrammarInclude) {
+								let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];
+								if (externalIncludedRule) ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);
+							} else ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);
+						}
+				}
+			} else ruleId = _RuleFactory.getCompiledRuleId(pattern, helper, repository);
+			if (ruleId !== -1) {
+				const rule = helper.getRule(ruleId);
+				let skipRule = false;
+				if (rule instanceof IncludeOnlyRule || rule instanceof BeginEndRule || rule instanceof BeginWhileRule) {
+					if (rule.hasMissingPatterns && rule.patterns.length === 0) skipRule = true;
+				}
+				if (skipRule) continue;
+				r.push(ruleId);
+			}
+		}
+		return {
+			patterns: r,
+			hasMissingPatterns: (patterns ? patterns.length : 0) !== r.length
+		};
+	}
+};
+var RegExpSource = class _RegExpSource {
+	source;
+	ruleId;
+	hasAnchor;
+	hasBackReferences;
+	_anchorCache;
+	constructor(regExpSource, ruleId) {
+		if (regExpSource && typeof regExpSource === "string") {
+			const len = regExpSource.length;
+			let lastPushedPos = 0;
+			let output = [];
+			let hasAnchor = false;
+			for (let pos = 0; pos < len; pos++) if (regExpSource.charAt(pos) === "\\") {
+				if (pos + 1 < len) {
+					const nextCh = regExpSource.charAt(pos + 1);
+					if (nextCh === "z") {
+						output.push(regExpSource.substring(lastPushedPos, pos));
+						output.push("$(?!\\n)(?<!\\n)");
+						lastPushedPos = pos + 2;
+					} else if (nextCh === "A" || nextCh === "G") hasAnchor = true;
+					pos++;
+				}
+			}
+			this.hasAnchor = hasAnchor;
+			if (lastPushedPos === 0) this.source = regExpSource;
+			else {
+				output.push(regExpSource.substring(lastPushedPos, len));
+				this.source = output.join("");
+			}
+		} else {
+			this.hasAnchor = false;
+			this.source = regExpSource;
+		}
+		if (this.hasAnchor) this._anchorCache = this._buildAnchorCache();
+		else this._anchorCache = null;
+		this.ruleId = ruleId;
+		if (typeof this.source === "string") this.hasBackReferences = HAS_BACK_REFERENCES.test(this.source);
+		else this.hasBackReferences = false;
+	}
+	clone() {
+		return new _RegExpSource(this.source, this.ruleId);
+	}
+	setSource(newSource) {
+		if (this.source === newSource) return;
+		this.source = newSource;
+		if (this.hasAnchor) this._anchorCache = this._buildAnchorCache();
+	}
+	resolveBackReferences(lineText, captureIndices) {
+		if (typeof this.source !== "string") throw new Error("This method should only be called if the source is a string");
+		let capturedValues = captureIndices.map((capture) => {
+			return lineText.substring(capture.start, capture.end);
+		});
+		BACK_REFERENCING_END.lastIndex = 0;
+		return this.source.replace(BACK_REFERENCING_END, (match, g1) => {
+			return escapeRegExpCharacters(capturedValues[parseInt(g1, 10)] || "");
+		});
+	}
+	_buildAnchorCache() {
+		if (typeof this.source !== "string") throw new Error("This method should only be called if the source is a string");
+		let A0_G0_result = [];
+		let A0_G1_result = [];
+		let A1_G0_result = [];
+		let A1_G1_result = [];
+		let pos, len, ch, nextCh;
+		for (pos = 0, len = this.source.length; pos < len; pos++) {
+			ch = this.source.charAt(pos);
+			A0_G0_result[pos] = ch;
+			A0_G1_result[pos] = ch;
+			A1_G0_result[pos] = ch;
+			A1_G1_result[pos] = ch;
+			if (ch === "\\") {
+				if (pos + 1 < len) {
+					nextCh = this.source.charAt(pos + 1);
+					if (nextCh === "A") {
+						A0_G0_result[pos + 1] = "￿";
+						A0_G1_result[pos + 1] = "￿";
+						A1_G0_result[pos + 1] = "A";
+						A1_G1_result[pos + 1] = "A";
+					} else if (nextCh === "G") {
+						A0_G0_result[pos + 1] = "￿";
+						A0_G1_result[pos + 1] = "G";
+						A1_G0_result[pos + 1] = "￿";
+						A1_G1_result[pos + 1] = "G";
+					} else {
+						A0_G0_result[pos + 1] = nextCh;
+						A0_G1_result[pos + 1] = nextCh;
+						A1_G0_result[pos + 1] = nextCh;
+						A1_G1_result[pos + 1] = nextCh;
+					}
+					pos++;
+				}
+			}
+		}
+		return {
+			A0_G0: A0_G0_result.join(""),
+			A0_G1: A0_G1_result.join(""),
+			A1_G0: A1_G0_result.join(""),
+			A1_G1: A1_G1_result.join("")
+		};
+	}
+	resolveAnchors(allowA, allowG) {
+		if (!this.hasAnchor || !this._anchorCache || typeof this.source !== "string") return this.source;
+		if (allowA) {
+			if (allowG) return this._anchorCache.A1_G1;
+			else return this._anchorCache.A1_G0;
+		} else if (allowG) return this._anchorCache.A0_G1;
+		else return this._anchorCache.A0_G0;
+	}
+};
+var RegExpSourceList = class {
+	_items;
+	_hasAnchors;
+	_cached;
+	_anchorCache;
+	constructor() {
+		this._items = [];
+		this._hasAnchors = false;
+		this._cached = null;
+		this._anchorCache = {
+			A0_G0: null,
+			A0_G1: null,
+			A1_G0: null,
+			A1_G1: null
+		};
+	}
+	dispose() {
+		this._disposeCaches();
+	}
+	_disposeCaches() {
+		if (this._cached) {
+			this._cached.dispose();
+			this._cached = null;
+		}
+		if (this._anchorCache.A0_G0) {
+			this._anchorCache.A0_G0.dispose();
+			this._anchorCache.A0_G0 = null;
+		}
+		if (this._anchorCache.A0_G1) {
+			this._anchorCache.A0_G1.dispose();
+			this._anchorCache.A0_G1 = null;
+		}
+		if (this._anchorCache.A1_G0) {
+			this._anchorCache.A1_G0.dispose();
+			this._anchorCache.A1_G0 = null;
+		}
+		if (this._anchorCache.A1_G1) {
+			this._anchorCache.A1_G1.dispose();
+			this._anchorCache.A1_G1 = null;
+		}
+	}
+	push(item) {
+		this._items.push(item);
+		this._hasAnchors = this._hasAnchors || item.hasAnchor;
+	}
+	unshift(item) {
+		this._items.unshift(item);
+		this._hasAnchors = this._hasAnchors || item.hasAnchor;
+	}
+	length() {
+		return this._items.length;
+	}
+	setSource(index, newSource) {
+		if (this._items[index].source !== newSource) {
+			this._disposeCaches();
+			this._items[index].setSource(newSource);
+		}
+	}
+	compile(onigLib) {
+		if (!this._cached) {
+			let regExps = this._items.map((e) => e.source);
+			this._cached = new CompiledRule(onigLib, regExps, this._items.map((e) => e.ruleId));
+		}
+		return this._cached;
+	}
+	compileAG(onigLib, allowA, allowG) {
+		if (!this._hasAnchors) return this.compile(onigLib);
+		else if (allowA) {
+			if (allowG) {
+				if (!this._anchorCache.A1_G1) this._anchorCache.A1_G1 = this._resolveAnchors(onigLib, allowA, allowG);
+				return this._anchorCache.A1_G1;
+			} else {
+				if (!this._anchorCache.A1_G0) this._anchorCache.A1_G0 = this._resolveAnchors(onigLib, allowA, allowG);
+				return this._anchorCache.A1_G0;
+			}
+		} else if (allowG) {
+			if (!this._anchorCache.A0_G1) this._anchorCache.A0_G1 = this._resolveAnchors(onigLib, allowA, allowG);
+			return this._anchorCache.A0_G1;
+		} else {
+			if (!this._anchorCache.A0_G0) this._anchorCache.A0_G0 = this._resolveAnchors(onigLib, allowA, allowG);
+			return this._anchorCache.A0_G0;
+		}
+	}
+	_resolveAnchors(onigLib, allowA, allowG) {
+		return new CompiledRule(onigLib, this._items.map((e) => e.resolveAnchors(allowA, allowG)), this._items.map((e) => e.ruleId));
+	}
+};
+var CompiledRule = class {
+	constructor(onigLib, regExps, rules) {
+		this.regExps = regExps;
+		this.rules = rules;
+		this.scanner = onigLib.createOnigScanner(regExps);
+	}
+	scanner;
+	dispose() {
+		if (typeof this.scanner.dispose === "function") this.scanner.dispose();
+	}
+	toString() {
+		const r = [];
+		for (let i = 0, len = this.rules.length; i < len; i++) r.push("   - " + this.rules[i] + ": " + this.regExps[i]);
+		return r.join("\n");
+	}
+	findNextMatchSync(string, startPosition, options) {
+		const result = this.scanner.findNextMatchSync(string, startPosition, options);
+		if (!result) return null;
+		return {
+			ruleId: this.rules[result.index],
+			captureIndices: result.captureIndices
+		};
+	}
+};
+var BasicScopeAttributes = class {
+	constructor(languageId, tokenType) {
+		this.languageId = languageId;
+		this.tokenType = tokenType;
+	}
+};
+var BasicScopeAttributesProvider = class _BasicScopeAttributesProvider {
+	_defaultAttributes;
+	_embeddedLanguagesMatcher;
+	constructor(initialLanguageId, embeddedLanguages) {
+		this._defaultAttributes = new BasicScopeAttributes(initialLanguageId, 8);
+		this._embeddedLanguagesMatcher = new ScopeMatcher(Object.entries(embeddedLanguages || {}));
+	}
+	getDefaultAttributes() {
+		return this._defaultAttributes;
+	}
+	getBasicScopeAttributes(scopeName) {
+		if (scopeName === null) return _BasicScopeAttributesProvider._NULL_SCOPE_METADATA;
+		return this._getBasicScopeAttributes.get(scopeName);
+	}
+	static _NULL_SCOPE_METADATA = new BasicScopeAttributes(0, 0);
+	_getBasicScopeAttributes = new CachedFn((scopeName) => {
+		return new BasicScopeAttributes(this._scopeToLanguage(scopeName), this._toStandardTokenType(scopeName));
+	});
+	/**
+	* Given a produced TM scope, return the language that token describes or null if unknown.
+	* e.g. source.html => html, source.css.embedded.html => css, punctuation.definition.tag.html => null
+	*/
+	_scopeToLanguage(scope) {
+		return this._embeddedLanguagesMatcher.match(scope) || 0;
+	}
+	_toStandardTokenType(scopeName) {
+		const m = scopeName.match(_BasicScopeAttributesProvider.STANDARD_TOKEN_TYPE_REGEXP);
+		if (!m) return 8;
+		switch (m[1]) {
+			case "comment": return 1;
+			case "string": return 2;
+			case "regex": return 3;
+			case "meta.embedded": return 0;
+		}
+		throw new Error("Unexpected match for standard token type!");
+	}
+	static STANDARD_TOKEN_TYPE_REGEXP = /\b(comment|string|regex|meta\.embedded)\b/;
+};
+var ScopeMatcher = class {
+	values;
+	scopesRegExp;
+	constructor(values) {
+		if (values.length === 0) {
+			this.values = null;
+			this.scopesRegExp = null;
+		} else {
+			this.values = new Map(values);
+			const escapedScopes = values.map(([scopeName, value]) => escapeRegExpCharacters(scopeName));
+			escapedScopes.sort();
+			escapedScopes.reverse();
+			this.scopesRegExp = new RegExp(`^((${escapedScopes.join(")|(")}))($|\\.)`, "");
+		}
+	}
+	match(scope) {
+		if (!this.scopesRegExp) return;
+		const m = scope.match(this.scopesRegExp);
+		if (!m) return;
+		return this.values.get(m[1]);
+	}
+};
+typeof process !== "undefined" && process.env["VSCODE_TEXTMATE_DEBUG"];
+var UseOnigurumaFindOptions = false;
+var TokenizeStringResult = class {
+	constructor(stack, stoppedEarly) {
+		this.stack = stack;
+		this.stoppedEarly = stoppedEarly;
+	}
+};
+function _tokenizeString(grammar, lineText, isFirstLine, linePos, stack, lineTokens, checkWhileConditions, timeLimit) {
+	const lineLength = lineText.content.length;
+	let STOP = false;
+	let anchorPosition = -1;
+	if (checkWhileConditions) {
+		const whileCheckResult = _checkWhileConditions(grammar, lineText, isFirstLine, linePos, stack, lineTokens);
+		stack = whileCheckResult.stack;
+		linePos = whileCheckResult.linePos;
+		isFirstLine = whileCheckResult.isFirstLine;
+		anchorPosition = whileCheckResult.anchorPosition;
+	}
+	const startTime = Date.now();
+	while (!STOP) {
+		if (timeLimit !== 0) {
+			if (Date.now() - startTime > timeLimit) return new TokenizeStringResult(stack, true);
+		}
+		scanNext();
+	}
+	return new TokenizeStringResult(stack, false);
+	function scanNext() {
+		const r = matchRuleOrInjections(grammar, lineText, isFirstLine, linePos, stack, anchorPosition);
+		if (!r) {
+			lineTokens.produce(stack, lineLength);
+			STOP = true;
+			return;
+		}
+		const captureIndices = r.captureIndices;
+		const matchedRuleId = r.matchedRuleId;
+		const hasAdvanced = captureIndices && captureIndices.length > 0 ? captureIndices[0].end > linePos : false;
+		if (matchedRuleId === endRuleId) {
+			const poppedRule = stack.getRule(grammar);
+			lineTokens.produce(stack, captureIndices[0].start);
+			stack = stack.withContentNameScopesList(stack.nameScopesList);
+			handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, poppedRule.endCaptures, captureIndices);
+			lineTokens.produce(stack, captureIndices[0].end);
+			const popped = stack;
+			stack = stack.parent;
+			anchorPosition = popped.getAnchorPos();
+			if (!hasAdvanced && popped.getEnterPos() === linePos) {
+				stack = popped;
+				lineTokens.produce(stack, lineLength);
+				STOP = true;
+				return;
+			}
+		} else {
+			const _rule = grammar.getRule(matchedRuleId);
+			lineTokens.produce(stack, captureIndices[0].start);
+			const beforePush = stack;
+			const scopeName = _rule.getName(lineText.content, captureIndices);
+			const nameScopesList = stack.contentNameScopesList.pushAttributed(scopeName, grammar);
+			stack = stack.push(matchedRuleId, linePos, anchorPosition, captureIndices[0].end === lineLength, null, nameScopesList, nameScopesList);
+			if (_rule instanceof BeginEndRule) {
+				const pushedRule = _rule;
+				handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, pushedRule.beginCaptures, captureIndices);
+				lineTokens.produce(stack, captureIndices[0].end);
+				anchorPosition = captureIndices[0].end;
+				const contentName = pushedRule.getContentName(lineText.content, captureIndices);
+				const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);
+				stack = stack.withContentNameScopesList(contentNameScopesList);
+				if (pushedRule.endHasBackReferences) stack = stack.withEndRule(pushedRule.getEndWithResolvedBackReferences(lineText.content, captureIndices));
+				if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
+					stack = stack.pop();
+					lineTokens.produce(stack, lineLength);
+					STOP = true;
+					return;
+				}
+			} else if (_rule instanceof BeginWhileRule) {
+				const pushedRule = _rule;
+				handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, pushedRule.beginCaptures, captureIndices);
+				lineTokens.produce(stack, captureIndices[0].end);
+				anchorPosition = captureIndices[0].end;
+				const contentName = pushedRule.getContentName(lineText.content, captureIndices);
+				const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);
+				stack = stack.withContentNameScopesList(contentNameScopesList);
+				if (pushedRule.whileHasBackReferences) stack = stack.withEndRule(pushedRule.getWhileWithResolvedBackReferences(lineText.content, captureIndices));
+				if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
+					stack = stack.pop();
+					lineTokens.produce(stack, lineLength);
+					STOP = true;
+					return;
+				}
+			} else {
+				handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, _rule.captures, captureIndices);
+				lineTokens.produce(stack, captureIndices[0].end);
+				stack = stack.pop();
+				if (!hasAdvanced) {
+					stack = stack.safePop();
+					lineTokens.produce(stack, lineLength);
+					STOP = true;
+					return;
+				}
+			}
+		}
+		if (captureIndices[0].end > linePos) {
+			linePos = captureIndices[0].end;
+			isFirstLine = false;
+		}
+	}
+}
+function _checkWhileConditions(grammar, lineText, isFirstLine, linePos, stack, lineTokens) {
+	let anchorPosition = stack.beginRuleCapturedEOL ? 0 : -1;
+	const whileRules = [];
+	for (let node = stack; node; node = node.pop()) {
+		const nodeRule = node.getRule(grammar);
+		if (nodeRule instanceof BeginWhileRule) whileRules.push({
+			rule: nodeRule,
+			stack: node
+		});
+	}
+	for (let whileRule = whileRules.pop(); whileRule; whileRule = whileRules.pop()) {
+		const { ruleScanner, findOptions } = prepareRuleWhileSearch(whileRule.rule, grammar, whileRule.stack.endRule, isFirstLine, linePos === anchorPosition);
+		const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
+		if (r) {
+			if (r.ruleId !== whileRuleId) {
+				stack = whileRule.stack.pop();
+				break;
+			}
+			if (r.captureIndices && r.captureIndices.length) {
+				lineTokens.produce(whileRule.stack, r.captureIndices[0].start);
+				handleCaptures(grammar, lineText, isFirstLine, whileRule.stack, lineTokens, whileRule.rule.whileCaptures, r.captureIndices);
+				lineTokens.produce(whileRule.stack, r.captureIndices[0].end);
+				anchorPosition = r.captureIndices[0].end;
+				if (r.captureIndices[0].end > linePos) {
+					linePos = r.captureIndices[0].end;
+					isFirstLine = false;
+				}
+			}
+		} else {
+			stack = whileRule.stack.pop();
+			break;
+		}
+	}
+	return {
+		stack,
+		linePos,
+		anchorPosition,
+		isFirstLine
+	};
+}
+function matchRuleOrInjections(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
+	const matchResult = matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition);
+	const injections = grammar.getInjections();
+	if (injections.length === 0) return matchResult;
+	const injectionResult = matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition);
+	if (!injectionResult) return matchResult;
+	if (!matchResult) return injectionResult;
+	const matchResultScore = matchResult.captureIndices[0].start;
+	const injectionResultScore = injectionResult.captureIndices[0].start;
+	if (injectionResultScore < matchResultScore || injectionResult.priorityMatch && injectionResultScore === matchResultScore) return injectionResult;
+	return matchResult;
+}
+function matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
+	const { ruleScanner, findOptions } = prepareRuleSearch(stack.getRule(grammar), grammar, stack.endRule, isFirstLine, linePos === anchorPosition);
+	const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
+	if (r) return {
+		captureIndices: r.captureIndices,
+		matchedRuleId: r.ruleId
+	};
+	return null;
+}
+function matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
+	let bestMatchRating = Number.MAX_VALUE;
+	let bestMatchCaptureIndices = null;
+	let bestMatchRuleId;
+	let bestMatchResultPriority = 0;
+	const scopes = stack.contentNameScopesList.getScopeNames();
+	for (let i = 0, len = injections.length; i < len; i++) {
+		const injection = injections[i];
+		if (!injection.matcher(scopes)) continue;
+		const { ruleScanner, findOptions } = prepareRuleSearch(grammar.getRule(injection.ruleId), grammar, null, isFirstLine, linePos === anchorPosition);
+		const matchResult = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
+		if (!matchResult) continue;
+		const matchRating = matchResult.captureIndices[0].start;
+		if (matchRating >= bestMatchRating) continue;
+		bestMatchRating = matchRating;
+		bestMatchCaptureIndices = matchResult.captureIndices;
+		bestMatchRuleId = matchResult.ruleId;
+		bestMatchResultPriority = injection.priority;
+		if (bestMatchRating === linePos) break;
+	}
+	if (bestMatchCaptureIndices) return {
+		priorityMatch: bestMatchResultPriority === -1,
+		captureIndices: bestMatchCaptureIndices,
+		matchedRuleId: bestMatchRuleId
+	};
+	return null;
+}
+function prepareRuleSearch(rule, grammar, endRegexSource, allowA, allowG) {
+	if (UseOnigurumaFindOptions) return {
+		ruleScanner: rule.compile(grammar, endRegexSource),
+		findOptions: getFindOptions(allowA, allowG)
+	};
+	return {
+		ruleScanner: rule.compileAG(grammar, endRegexSource, allowA, allowG),
+		findOptions: 0
+	};
+}
+function prepareRuleWhileSearch(rule, grammar, endRegexSource, allowA, allowG) {
+	if (UseOnigurumaFindOptions) return {
+		ruleScanner: rule.compileWhile(grammar, endRegexSource),
+		findOptions: getFindOptions(allowA, allowG)
+	};
+	return {
+		ruleScanner: rule.compileWhileAG(grammar, endRegexSource, allowA, allowG),
+		findOptions: 0
+	};
+}
+function getFindOptions(allowA, allowG) {
+	let options = 0;
+	if (!allowA) options |= 1;
+	if (!allowG) options |= 4;
+	return options;
+}
+function handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, captures, captureIndices) {
+	if (captures.length === 0) return;
+	const lineTextContent = lineText.content;
+	const len = Math.min(captures.length, captureIndices.length);
+	const localStack = [];
+	const maxEnd = captureIndices[0].end;
+	for (let i = 0; i < len; i++) {
+		const captureRule = captures[i];
+		if (captureRule === null) continue;
+		const captureIndex = captureIndices[i];
+		if (captureIndex.length === 0) continue;
+		if (captureIndex.start > maxEnd) break;
+		while (localStack.length > 0 && localStack[localStack.length - 1].endPos <= captureIndex.start) {
+			lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);
+			localStack.pop();
+		}
+		if (localStack.length > 0) lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, captureIndex.start);
+		else lineTokens.produce(stack, captureIndex.start);
+		if (captureRule.retokenizeCapturedWithRuleId) {
+			const scopeName = captureRule.getName(lineTextContent, captureIndices);
+			const nameScopesList = stack.contentNameScopesList.pushAttributed(scopeName, grammar);
+			const contentName = captureRule.getContentName(lineTextContent, captureIndices);
+			const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);
+			const stackClone = stack.push(captureRule.retokenizeCapturedWithRuleId, captureIndex.start, -1, false, null, nameScopesList, contentNameScopesList);
+			const onigSubStr = grammar.createOnigString(lineTextContent.substring(0, captureIndex.end));
+			_tokenizeString(grammar, onigSubStr, isFirstLine && captureIndex.start === 0, captureIndex.start, stackClone, lineTokens, false, 0);
+			disposeOnigString(onigSubStr);
+			continue;
+		}
+		const captureRuleScopeName = captureRule.getName(lineTextContent, captureIndices);
+		if (captureRuleScopeName !== null) {
+			const captureRuleScopesList = (localStack.length > 0 ? localStack[localStack.length - 1].scopes : stack.contentNameScopesList).pushAttributed(captureRuleScopeName, grammar);
+			localStack.push(new LocalStackElement(captureRuleScopesList, captureIndex.end));
+		}
+	}
+	while (localStack.length > 0) {
+		lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);
+		localStack.pop();
+	}
+}
+var LocalStackElement = class {
+	scopes;
+	endPos;
+	constructor(scopes, endPos) {
+		this.scopes = scopes;
+		this.endPos = endPos;
+	}
+};
+function createGrammar(scopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, onigLib) {
+	return new Grammar(scopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, onigLib);
+}
+function collectInjections(result, selector, rule, ruleFactoryHelper, grammar) {
+	const matchers = createMatchers(selector, nameMatcher);
+	const ruleId = RuleFactory.getCompiledRuleId(rule, ruleFactoryHelper, grammar.repository);
+	for (const matcher of matchers) result.push({
+		debugSelector: selector,
+		matcher: matcher.matcher,
+		ruleId,
+		grammar,
+		priority: matcher.priority
+	});
+}
+function nameMatcher(identifers, scopes) {
+	if (scopes.length < identifers.length) return false;
+	let lastIndex = 0;
+	return identifers.every((identifier) => {
+		for (let i = lastIndex; i < scopes.length; i++) if (scopesAreMatching(scopes[i], identifier)) {
+			lastIndex = i + 1;
+			return true;
+		}
+		return false;
+	});
+}
+function scopesAreMatching(thisScopeName, scopeName) {
+	if (!thisScopeName) return false;
+	if (thisScopeName === scopeName) return true;
+	const len = scopeName.length;
+	return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === ".";
+}
+var Grammar = class {
+	constructor(_rootScopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, _onigLib) {
+		this._rootScopeName = _rootScopeName;
+		this.balancedBracketSelectors = balancedBracketSelectors;
+		this._onigLib = _onigLib;
+		this._basicScopeAttributesProvider = new BasicScopeAttributesProvider(initialLanguage, embeddedLanguages);
+		this._rootId = -1;
+		this._lastRuleId = 0;
+		this._ruleId2desc = [null];
+		this._includedGrammars = {};
+		this._grammarRepository = grammarRepository;
+		this._grammar = initGrammar(grammar, null);
+		this._injections = null;
+		this._tokenTypeMatchers = [];
+		if (tokenTypes) for (const selector of Object.keys(tokenTypes)) {
+			const matchers = createMatchers(selector, nameMatcher);
+			for (const matcher of matchers) this._tokenTypeMatchers.push({
+				matcher: matcher.matcher,
+				type: tokenTypes[selector]
+			});
+		}
+	}
+	_rootId;
+	_lastRuleId;
+	_ruleId2desc;
+	_includedGrammars;
+	_grammarRepository;
+	_grammar;
+	_injections;
+	_basicScopeAttributesProvider;
+	_tokenTypeMatchers;
+	get themeProvider() {
+		return this._grammarRepository;
+	}
+	dispose() {
+		for (const rule of this._ruleId2desc) if (rule) rule.dispose();
+	}
+	createOnigScanner(sources) {
+		return this._onigLib.createOnigScanner(sources);
+	}
+	createOnigString(sources) {
+		return this._onigLib.createOnigString(sources);
+	}
+	getMetadataForScope(scope) {
+		return this._basicScopeAttributesProvider.getBasicScopeAttributes(scope);
+	}
+	_collectInjections() {
+		const grammarRepository = {
+			lookup: (scopeName2) => {
+				if (scopeName2 === this._rootScopeName) return this._grammar;
+				return this.getExternalGrammar(scopeName2);
+			},
+			injections: (scopeName2) => {
+				return this._grammarRepository.injections(scopeName2);
+			}
+		};
+		const result = [];
+		const scopeName = this._rootScopeName;
+		const grammar = grammarRepository.lookup(scopeName);
+		if (grammar) {
+			const rawInjections = grammar.injections;
+			if (rawInjections) for (let expression in rawInjections) collectInjections(result, expression, rawInjections[expression], this, grammar);
+			const injectionScopeNames = this._grammarRepository.injections(scopeName);
+			if (injectionScopeNames) injectionScopeNames.forEach((injectionScopeName) => {
+				const injectionGrammar = this.getExternalGrammar(injectionScopeName);
+				if (injectionGrammar) {
+					const selector = injectionGrammar.injectionSelector;
+					if (selector) collectInjections(result, selector, injectionGrammar, this, injectionGrammar);
+				}
+			});
+		}
+		result.sort((i1, i2) => i1.priority - i2.priority);
+		return result;
+	}
+	getInjections() {
+		if (this._injections === null) this._injections = this._collectInjections();
+		return this._injections;
+	}
+	registerRule(factory) {
+		const id = ++this._lastRuleId;
+		const result = factory(ruleIdFromNumber(id));
+		this._ruleId2desc[id] = result;
+		return result;
+	}
+	getRule(ruleId) {
+		return this._ruleId2desc[ruleIdToNumber(ruleId)];
+	}
+	getExternalGrammar(scopeName, repository) {
+		if (this._includedGrammars[scopeName]) return this._includedGrammars[scopeName];
+		else if (this._grammarRepository) {
+			const rawIncludedGrammar = this._grammarRepository.lookup(scopeName);
+			if (rawIncludedGrammar) {
+				this._includedGrammars[scopeName] = initGrammar(rawIncludedGrammar, repository && repository.$base);
+				return this._includedGrammars[scopeName];
+			}
+		}
+	}
+	tokenizeLine(lineText, prevState, timeLimit = 0) {
+		const r = this._tokenize(lineText, prevState, false, timeLimit);
+		return {
+			tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),
+			ruleStack: r.ruleStack,
+			stoppedEarly: r.stoppedEarly
+		};
+	}
+	tokenizeLine2(lineText, prevState, timeLimit = 0) {
+		const r = this._tokenize(lineText, prevState, true, timeLimit);
+		return {
+			tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),
+			ruleStack: r.ruleStack,
+			stoppedEarly: r.stoppedEarly
+		};
+	}
+	_tokenize(lineText, prevState, emitBinaryTokens, timeLimit) {
+		if (this._rootId === -1) {
+			this._rootId = RuleFactory.getCompiledRuleId(this._grammar.repository.$self, this, this._grammar.repository);
+			this.getInjections();
+		}
+		let isFirstLine;
+		if (!prevState || prevState === StateStackImpl.NULL) {
+			isFirstLine = true;
+			const rawDefaultMetadata = this._basicScopeAttributesProvider.getDefaultAttributes();
+			const defaultStyle = this.themeProvider.getDefaults();
+			const defaultMetadata = EncodedTokenMetadata.set(0, rawDefaultMetadata.languageId, rawDefaultMetadata.tokenType, null, defaultStyle.fontStyle, defaultStyle.foregroundId, defaultStyle.backgroundId);
+			const rootScopeName = this.getRule(this._rootId).getName(null, null);
+			let scopeList;
+			if (rootScopeName) scopeList = AttributedScopeStack.createRootAndLookUpScopeName(rootScopeName, defaultMetadata, this);
+			else scopeList = AttributedScopeStack.createRoot("unknown", defaultMetadata);
+			prevState = new StateStackImpl(null, this._rootId, -1, -1, false, null, scopeList, scopeList);
+		} else {
+			isFirstLine = false;
+			prevState.reset();
+		}
+		lineText = lineText + "\n";
+		const onigLineText = this.createOnigString(lineText);
+		const lineLength = onigLineText.content.length;
+		const lineTokens = new LineTokens(emitBinaryTokens, lineText, this._tokenTypeMatchers, this.balancedBracketSelectors);
+		const r = _tokenizeString(this, onigLineText, isFirstLine, 0, prevState, lineTokens, true, timeLimit);
+		disposeOnigString(onigLineText);
+		return {
+			lineLength,
+			lineTokens,
+			ruleStack: r.stack,
+			stoppedEarly: r.stoppedEarly
+		};
+	}
+};
+function initGrammar(grammar, base) {
+	grammar = clone(grammar);
+	grammar.repository = grammar.repository || {};
+	grammar.repository.$self = {
+		$vscodeTextmateLocation: grammar.$vscodeTextmateLocation,
+		patterns: grammar.patterns,
+		name: grammar.scopeName
+	};
+	grammar.repository.$base = base || grammar.repository.$self;
+	return grammar;
+}
+var AttributedScopeStack = class _AttributedScopeStack {
+	/**
+	* Invariant:
+	* ```
+	* if (parent && !scopePath.extends(parent.scopePath)) {
+	* 	throw new Error();
+	* }
+	* ```
+	*/
+	constructor(parent, scopePath, tokenAttributes) {
+		this.parent = parent;
+		this.scopePath = scopePath;
+		this.tokenAttributes = tokenAttributes;
+	}
+	static fromExtension(namesScopeList, contentNameScopesList) {
+		let current = namesScopeList;
+		let scopeNames = namesScopeList?.scopePath ?? null;
+		for (const frame of contentNameScopesList) {
+			scopeNames = ScopeStack.push(scopeNames, frame.scopeNames);
+			current = new _AttributedScopeStack(current, scopeNames, frame.encodedTokenAttributes);
+		}
+		return current;
+	}
+	static createRoot(scopeName, tokenAttributes) {
+		return new _AttributedScopeStack(null, new ScopeStack(null, scopeName), tokenAttributes);
+	}
+	static createRootAndLookUpScopeName(scopeName, tokenAttributes, grammar) {
+		const rawRootMetadata = grammar.getMetadataForScope(scopeName);
+		const scopePath = new ScopeStack(null, scopeName);
+		const rootStyle = grammar.themeProvider.themeMatch(scopePath);
+		const resolvedTokenAttributes = _AttributedScopeStack.mergeAttributes(tokenAttributes, rawRootMetadata, rootStyle);
+		return new _AttributedScopeStack(null, scopePath, resolvedTokenAttributes);
+	}
+	get scopeName() {
+		return this.scopePath.scopeName;
+	}
+	toString() {
+		return this.getScopeNames().join(" ");
+	}
+	equals(other) {
+		return _AttributedScopeStack.equals(this, other);
+	}
+	static equals(a, b) {
+		do {
+			if (a === b) return true;
+			if (!a && !b) return true;
+			if (!a || !b) return false;
+			if (a.scopeName !== b.scopeName || a.tokenAttributes !== b.tokenAttributes) return false;
+			a = a.parent;
+			b = b.parent;
+		} while (true);
+	}
+	static mergeAttributes(existingTokenAttributes, basicScopeAttributes, styleAttributes) {
+		let fontStyle = -1;
+		let foreground = 0;
+		let background = 0;
+		if (styleAttributes !== null) {
+			fontStyle = styleAttributes.fontStyle;
+			foreground = styleAttributes.foregroundId;
+			background = styleAttributes.backgroundId;
+		}
+		return EncodedTokenMetadata.set(existingTokenAttributes, basicScopeAttributes.languageId, basicScopeAttributes.tokenType, null, fontStyle, foreground, background);
+	}
+	pushAttributed(scopePath, grammar) {
+		if (scopePath === null) return this;
+		if (scopePath.indexOf(" ") === -1) return _AttributedScopeStack._pushAttributed(this, scopePath, grammar);
+		const scopes = scopePath.split(/ /g);
+		let result = this;
+		for (const scope of scopes) result = _AttributedScopeStack._pushAttributed(result, scope, grammar);
+		return result;
+	}
+	static _pushAttributed(target, scopeName, grammar) {
+		const rawMetadata = grammar.getMetadataForScope(scopeName);
+		const newPath = target.scopePath.push(scopeName);
+		const scopeThemeMatchResult = grammar.themeProvider.themeMatch(newPath);
+		const metadata = _AttributedScopeStack.mergeAttributes(target.tokenAttributes, rawMetadata, scopeThemeMatchResult);
+		return new _AttributedScopeStack(target, newPath, metadata);
+	}
+	getScopeNames() {
+		return this.scopePath.getSegments();
+	}
+	getExtensionIfDefined(base) {
+		const result = [];
+		let self = this;
+		while (self && self !== base) {
+			result.push({
+				encodedTokenAttributes: self.tokenAttributes,
+				scopeNames: self.scopePath.getExtensionIfDefined(self.parent?.scopePath ?? null)
+			});
+			self = self.parent;
+		}
+		return self === base ? result.reverse() : void 0;
+	}
+};
+var StateStackImpl = class _StateStackImpl {
+	/**
+	* Invariant:
+	* ```
+	* if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {
+	* 	throw new Error();
+	* }
+	* if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {
+	* 	throw new Error();
+	* }
+	* ```
+	*/
+	constructor(parent, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {
+		this.parent = parent;
+		this.ruleId = ruleId;
+		this.beginRuleCapturedEOL = beginRuleCapturedEOL;
+		this.endRule = endRule;
+		this.nameScopesList = nameScopesList;
+		this.contentNameScopesList = contentNameScopesList;
+		this.depth = this.parent ? this.parent.depth + 1 : 1;
+		this._enterPos = enterPos;
+		this._anchorPos = anchorPos;
+	}
+	_stackElementBrand = void 0;
+	static NULL = new _StateStackImpl(null, 0, 0, 0, false, null, null, null);
+	/**
+	* The position on the current line where this state was pushed.
+	* This is relevant only while tokenizing a line, to detect endless loops.
+	* Its value is meaningless across lines.
+	*/
+	_enterPos;
+	/**
+	* The captured anchor position when this stack element was pushed.
+	* This is relevant only while tokenizing a line, to restore the anchor position when popping.
+	* Its value is meaningless across lines.
+	*/
+	_anchorPos;
+	/**
+	* The depth of the stack.
+	*/
+	depth;
+	equals(other) {
+		if (other === null) return false;
+		return _StateStackImpl._equals(this, other);
+	}
+	static _equals(a, b) {
+		if (a === b) return true;
+		if (!this._structuralEquals(a, b)) return false;
+		return AttributedScopeStack.equals(a.contentNameScopesList, b.contentNameScopesList);
+	}
+	/**
+	* A structural equals check. Does not take into account `scopes`.
+	*/
+	static _structuralEquals(a, b) {
+		do {
+			if (a === b) return true;
+			if (!a && !b) return true;
+			if (!a || !b) return false;
+			if (a.depth !== b.depth || a.ruleId !== b.ruleId || a.endRule !== b.endRule) return false;
+			a = a.parent;
+			b = b.parent;
+		} while (true);
+	}
+	clone() {
+		return this;
+	}
+	static _reset(el) {
+		while (el) {
+			el._enterPos = -1;
+			el._anchorPos = -1;
+			el = el.parent;
+		}
+	}
+	reset() {
+		_StateStackImpl._reset(this);
+	}
+	pop() {
+		return this.parent;
+	}
+	safePop() {
+		if (this.parent) return this.parent;
+		return this;
+	}
+	push(ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {
+		return new _StateStackImpl(this, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList);
+	}
+	getEnterPos() {
+		return this._enterPos;
+	}
+	getAnchorPos() {
+		return this._anchorPos;
+	}
+	getRule(grammar) {
+		return grammar.getRule(this.ruleId);
+	}
+	toString() {
+		const r = [];
+		this._writeString(r, 0);
+		return "[" + r.join(",") + "]";
+	}
+	_writeString(res, outIndex) {
+		if (this.parent) outIndex = this.parent._writeString(res, outIndex);
+		res[outIndex++] = `(${this.ruleId}, ${this.nameScopesList?.toString()}, ${this.contentNameScopesList?.toString()})`;
+		return outIndex;
+	}
+	withContentNameScopesList(contentNameScopeStack) {
+		if (this.contentNameScopesList === contentNameScopeStack) return this;
+		return this.parent.push(this.ruleId, this._enterPos, this._anchorPos, this.beginRuleCapturedEOL, this.endRule, this.nameScopesList, contentNameScopeStack);
+	}
+	withEndRule(endRule) {
+		if (this.endRule === endRule) return this;
+		return new _StateStackImpl(this.parent, this.ruleId, this._enterPos, this._anchorPos, this.beginRuleCapturedEOL, endRule, this.nameScopesList, this.contentNameScopesList);
+	}
+	hasSameRuleAs(other) {
+		let el = this;
+		while (el && el._enterPos === other._enterPos) {
+			if (el.ruleId === other.ruleId) return true;
+			el = el.parent;
+		}
+		return false;
+	}
+	toStateStackFrame() {
+		return {
+			ruleId: ruleIdToNumber(this.ruleId),
+			beginRuleCapturedEOL: this.beginRuleCapturedEOL,
+			endRule: this.endRule,
+			nameScopesList: this.nameScopesList?.getExtensionIfDefined(this.parent?.nameScopesList ?? null) ?? [],
+			contentNameScopesList: this.contentNameScopesList?.getExtensionIfDefined(this.nameScopesList) ?? []
+		};
+	}
+	static pushFrame(self, frame) {
+		const namesScopeList = AttributedScopeStack.fromExtension(self?.nameScopesList ?? null, frame.nameScopesList);
+		return new _StateStackImpl(self, ruleIdFromNumber(frame.ruleId), frame.enterPos ?? -1, frame.anchorPos ?? -1, frame.beginRuleCapturedEOL, frame.endRule, namesScopeList, AttributedScopeStack.fromExtension(namesScopeList, frame.contentNameScopesList));
+	}
+};
+var BalancedBracketSelectors = class {
+	balancedBracketScopes;
+	unbalancedBracketScopes;
+	allowAny = false;
+	constructor(balancedBracketScopes, unbalancedBracketScopes) {
+		this.balancedBracketScopes = balancedBracketScopes.flatMap((selector) => {
+			if (selector === "*") {
+				this.allowAny = true;
+				return [];
+			}
+			return createMatchers(selector, nameMatcher).map((m) => m.matcher);
+		});
+		this.unbalancedBracketScopes = unbalancedBracketScopes.flatMap((selector) => createMatchers(selector, nameMatcher).map((m) => m.matcher));
+	}
+	get matchesAlways() {
+		return this.allowAny && this.unbalancedBracketScopes.length === 0;
+	}
+	get matchesNever() {
+		return this.balancedBracketScopes.length === 0 && !this.allowAny;
+	}
+	match(scopes) {
+		for (const excluder of this.unbalancedBracketScopes) if (excluder(scopes)) return false;
+		for (const includer of this.balancedBracketScopes) if (includer(scopes)) return true;
+		return this.allowAny;
+	}
+};
+var LineTokens = class {
+	constructor(emitBinaryTokens, lineText, tokenTypeOverrides, balancedBracketSelectors) {
+		this.balancedBracketSelectors = balancedBracketSelectors;
+		this._emitBinaryTokens = emitBinaryTokens;
+		this._tokenTypeOverrides = tokenTypeOverrides;
+		this._lineText = null;
+		this._tokens = [];
+		this._binaryTokens = [];
+		this._lastTokenEndIndex = 0;
+	}
+	_emitBinaryTokens;
+	/**
+	* defined only if `false`.
+	*/
+	_lineText;
+	/**
+	* used only if `_emitBinaryTokens` is false.
+	*/
+	_tokens;
+	/**
+	* used only if `_emitBinaryTokens` is true.
+	*/
+	_binaryTokens;
+	_lastTokenEndIndex;
+	_tokenTypeOverrides;
+	produce(stack, endIndex) {
+		this.produceFromScopes(stack.contentNameScopesList, endIndex);
+	}
+	produceFromScopes(scopesList, endIndex) {
+		if (this._lastTokenEndIndex >= endIndex) return;
+		if (this._emitBinaryTokens) {
+			let metadata = scopesList?.tokenAttributes ?? 0;
+			let containsBalancedBrackets = false;
+			if (this.balancedBracketSelectors?.matchesAlways) containsBalancedBrackets = true;
+			if (this._tokenTypeOverrides.length > 0 || this.balancedBracketSelectors && !this.balancedBracketSelectors.matchesAlways && !this.balancedBracketSelectors.matchesNever) {
+				const scopes2 = scopesList?.getScopeNames() ?? [];
+				for (const tokenType of this._tokenTypeOverrides) if (tokenType.matcher(scopes2)) metadata = EncodedTokenMetadata.set(metadata, 0, toOptionalTokenType(tokenType.type), null, -1, 0, 0);
+				if (this.balancedBracketSelectors) containsBalancedBrackets = this.balancedBracketSelectors.match(scopes2);
+			}
+			if (containsBalancedBrackets) metadata = EncodedTokenMetadata.set(metadata, 0, 8, containsBalancedBrackets, -1, 0, 0);
+			if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 1] === metadata) {
+				this._lastTokenEndIndex = endIndex;
+				return;
+			}
+			this._binaryTokens.push(this._lastTokenEndIndex);
+			this._binaryTokens.push(metadata);
+			this._lastTokenEndIndex = endIndex;
+			return;
+		}
+		const scopes = scopesList?.getScopeNames() ?? [];
+		this._tokens.push({
+			startIndex: this._lastTokenEndIndex,
+			endIndex,
+			scopes
+		});
+		this._lastTokenEndIndex = endIndex;
+	}
+	getResult(stack, lineLength) {
+		if (this._tokens.length > 0 && this._tokens[this._tokens.length - 1].startIndex === lineLength - 1) this._tokens.pop();
+		if (this._tokens.length === 0) {
+			this._lastTokenEndIndex = -1;
+			this.produce(stack, lineLength);
+			this._tokens[this._tokens.length - 1].startIndex = 0;
+		}
+		return this._tokens;
+	}
+	getBinaryResult(stack, lineLength) {
+		if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 2] === lineLength - 1) {
+			this._binaryTokens.pop();
+			this._binaryTokens.pop();
+		}
+		if (this._binaryTokens.length === 0) {
+			this._lastTokenEndIndex = -1;
+			this.produce(stack, lineLength);
+			this._binaryTokens[this._binaryTokens.length - 2] = 0;
+		}
+		const result = new Uint32Array(this._binaryTokens.length);
+		for (let i = 0, len = this._binaryTokens.length; i < len; i++) result[i] = this._binaryTokens[i];
+		return result;
+	}
+};
+var SyncRegistry = class {
+	constructor(theme, _onigLib) {
+		this._onigLib = _onigLib;
+		this._theme = theme;
+	}
+	_grammars = /* @__PURE__ */ new Map();
+	_rawGrammars = /* @__PURE__ */ new Map();
+	_injectionGrammars = /* @__PURE__ */ new Map();
+	_theme;
+	dispose() {
+		for (const grammar of this._grammars.values()) grammar.dispose();
+	}
+	setTheme(theme) {
+		this._theme = theme;
+	}
+	getColorMap() {
+		return this._theme.getColorMap();
+	}
+	/**
+	* Add `grammar` to registry and return a list of referenced scope names
+	*/
+	addGrammar(grammar, injectionScopeNames) {
+		this._rawGrammars.set(grammar.scopeName, grammar);
+		if (injectionScopeNames) this._injectionGrammars.set(grammar.scopeName, injectionScopeNames);
+	}
+	/**
+	* Lookup a raw grammar.
+	*/
+	lookup(scopeName) {
+		return this._rawGrammars.get(scopeName);
+	}
+	/**
+	* Returns the injections for the given grammar
+	*/
+	injections(targetScope) {
+		return this._injectionGrammars.get(targetScope);
+	}
+	/**
+	* Get the default theme settings
+	*/
+	getDefaults() {
+		return this._theme.getDefaults();
+	}
+	/**
+	* Match a scope in the theme.
+	*/
+	themeMatch(scopePath) {
+		return this._theme.match(scopePath);
+	}
+	/**
+	* Lookup a grammar.
+	*/
+	grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {
+		if (!this._grammars.has(scopeName)) {
+			let rawGrammar = this._rawGrammars.get(scopeName);
+			if (!rawGrammar) return null;
+			this._grammars.set(scopeName, createGrammar(scopeName, rawGrammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, this, this._onigLib));
+		}
+		return this._grammars.get(scopeName);
+	}
+};
+var Registry = class {
+	_options;
+	_syncRegistry;
+	_ensureGrammarCache;
+	constructor(options) {
+		this._options = options;
+		this._syncRegistry = new SyncRegistry(Theme.createFromRawTheme(options.theme, options.colorMap), options.onigLib);
+		this._ensureGrammarCache = /* @__PURE__ */ new Map();
+	}
+	dispose() {
+		this._syncRegistry.dispose();
+	}
+	/**
+	* Change the theme. Once called, no previous `ruleStack` should be used anymore.
+	*/
+	setTheme(theme, colorMap) {
+		this._syncRegistry.setTheme(Theme.createFromRawTheme(theme, colorMap));
+	}
+	/**
+	* Returns a lookup array for color ids.
+	*/
+	getColorMap() {
+		return this._syncRegistry.getColorMap();
+	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	* Please do not use language id 0.
+	*/
+	loadGrammarWithEmbeddedLanguages(initialScopeName, initialLanguage, embeddedLanguages) {
+		return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });
+	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	* Please do not use language id 0.
+	*/
+	loadGrammarWithConfiguration(initialScopeName, initialLanguage, configuration) {
+		return this._loadGrammar(initialScopeName, initialLanguage, configuration.embeddedLanguages, configuration.tokenTypes, new BalancedBracketSelectors(configuration.balancedBracketSelectors || [], configuration.unbalancedBracketSelectors || []));
+	}
+	/**
+	* Load the grammar for `scopeName` and all referenced included grammars asynchronously.
+	*/
+	loadGrammar(initialScopeName) {
+		return this._loadGrammar(initialScopeName, 0, null, null, null);
+	}
+	_loadGrammar(initialScopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {
+		const dependencyProcessor = new ScopeDependencyProcessor(this._syncRegistry, initialScopeName);
+		while (dependencyProcessor.Q.length > 0) {
+			dependencyProcessor.Q.map((request) => this._loadSingleGrammar(request.scopeName));
+			dependencyProcessor.processQueue();
+		}
+		return this._grammarForScopeName(initialScopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors);
+	}
+	_loadSingleGrammar(scopeName) {
+		if (!this._ensureGrammarCache.has(scopeName)) {
+			this._doLoadSingleGrammar(scopeName);
+			this._ensureGrammarCache.set(scopeName, true);
+		}
+	}
+	_doLoadSingleGrammar(scopeName) {
+		const grammar = this._options.loadGrammar(scopeName);
+		if (grammar) {
+			const injections = typeof this._options.getInjections === "function" ? this._options.getInjections(scopeName) : void 0;
+			this._syncRegistry.addGrammar(grammar, injections);
+		}
+	}
+	/**
+	* Adds a rawGrammar.
+	*/
+	addGrammar(rawGrammar, injections = [], initialLanguage = 0, embeddedLanguages = null) {
+		this._syncRegistry.addGrammar(rawGrammar, injections);
+		return this._grammarForScopeName(rawGrammar.scopeName, initialLanguage, embeddedLanguages);
+	}
+	/**
+	* Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.
+	*/
+	_grammarForScopeName(scopeName, initialLanguage = 0, embeddedLanguages = null, tokenTypes = null, balancedBracketSelectors = null) {
+		return this._syncRegistry.grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors);
+	}
+};
+var INITIAL = StateStackImpl.NULL;
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/managers/UniversalRenderingManager.js
+var callbacks = /* @__PURE__ */ new Set();
+var frameId = null;
+function queueRender(callback) {
+	callbacks.add(callback);
+	frameId ??= requestAnimationFrame(render);
+}
+function dequeueRender(callback) {
+	if (callbacks.delete(callback) && callbacks.size === 0 && frameId != null) {
+		cancelAnimationFrame(frameId);
+		frameId = null;
+	}
+}
+function render(time) {
+	const toIterate = new Set(callbacks);
+	callbacks.clear();
+	for (const callback of toIterate) try {
+		callback(time);
+	} catch (error) {
+		console.error(error);
+	}
+	if (callbacks.size > 0) frameId = requestAnimationFrame(render);
+	else frameId = null;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/isGutterUtilityPath.js
+function isGutterUtilityPath(path) {
+	for (const element of path) {
+		if (!(element instanceof HTMLElement)) continue;
+		if (element.hasAttribute("data-utility-button") || element.hasAttribute("data-gutter-utility-slot") || element.getAttribute("slot") === "gutter-utility-slot" || element.getAttribute("name") === "gutter-utility-slot") return true;
+	}
+	return false;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/getFiletypeFromFileName.js
+var CUSTOM_EXTENSION_TO_FILE_FORMAT = /* @__PURE__ */ new Map();
+var customExtensionsVersion = 0;
+var EXTENSION_TO_FILE_FORMAT = {
+	"1c": "1c",
+	abap: "abap",
+	as: "actionscript-3",
+	ada: "ada",
+	adb: "ada",
+	ads: "ada",
+	adoc: "asciidoc",
+	asciidoc: "asciidoc",
+	"component.html": "angular-html",
+	"component.ts": "angular-ts",
+	conf: "nginx",
+	htaccess: "apache",
+	cls: "tex",
+	trigger: "apex",
+	apl: "apl",
+	applescript: "applescript",
+	scpt: "applescript",
+	ara: "ara",
+	asm: "asm",
+	s: "riscv",
+	astro: "astro",
+	awk: "awk",
+	bal: "ballerina",
+	sh: "zsh",
+	bash: "zsh",
+	bat: "cmd",
+	cmd: "cmd",
+	be: "berry",
+	beancount: "beancount",
+	bib: "bibtex",
+	bicep: "bicep",
+	"blade.php": "blade",
+	bsl: "bsl",
+	c: "c",
+	h: "objective-cpp",
+	cs: "csharp",
+	cpp: "cpp",
+	hpp: "cpp",
+	cc: "cpp",
+	cxx: "cpp",
+	hh: "cpp",
+	cdc: "cdc",
+	cairo: "cairo",
+	clar: "clarity",
+	clj: "clojure",
+	cljs: "clojure",
+	cljc: "clojure",
+	soy: "soy",
+	cmake: "cmake",
+	"CMakeLists.txt": "cmake",
+	cob: "cobol",
+	cbl: "cobol",
+	cobol: "cobol",
+	CODEOWNERS: "codeowners",
+	ql: "ql",
+	coffee: "coffeescript",
+	lisp: "lisp",
+	cl: "lisp",
+	lsp: "lisp",
+	log: "log",
+	v: "verilog",
+	cql: "cql",
+	cr: "crystal",
+	css: "css",
+	csv: "csv",
+	cue: "cue",
+	cypher: "cypher",
+	cyp: "cypher",
+	d: "d",
+	dart: "dart",
+	dax: "dax",
+	desktop: "desktop",
+	diff: "diff",
+	patch: "diff",
+	Dockerfile: "dockerfile",
+	dockerfile: "dockerfile",
+	env: "dotenv",
+	dm: "dream-maker",
+	edge: "edge",
+	el: "emacs-lisp",
+	ex: "elixir",
+	exs: "elixir",
+	elm: "elm",
+	erb: "erb",
+	erl: "erlang",
+	hrl: "erlang",
+	f: "fortran-fixed-form",
+	for: "fortran-fixed-form",
+	fs: "fsharp",
+	fsi: "fsharp",
+	fsx: "fsharp",
+	f03: "f03",
+	f08: "f08",
+	f18: "f18",
+	f77: "f77",
+	f90: "fortran-free-form",
+	f95: "fortran-free-form",
+	fnl: "fennel",
+	fish: "fish",
+	ftl: "ftl",
+	tres: "gdresource",
+	res: "gdresource",
+	gd: "gdscript",
+	gdshader: "gdshader",
+	gs: "genie",
+	feature: "gherkin",
+	COMMIT_EDITMSG: "git-commit",
+	"git-rebase-todo": "git-rebase",
+	gjs: "glimmer-js",
+	gleam: "gleam",
+	gts: "glimmer-ts",
+	glsl: "glsl",
+	vert: "glsl",
+	frag: "glsl",
+	shader: "shaderlab",
+	gp: "gnuplot",
+	plt: "gnuplot",
+	gnuplot: "gnuplot",
+	go: "go",
+	graphql: "graphql",
+	gql: "graphql",
+	groovy: "groovy",
+	gvy: "groovy",
+	hack: "hack",
+	haml: "haml",
+	hbs: "handlebars",
+	handlebars: "handlebars",
+	hs: "haskell",
+	lhs: "haskell",
+	hx: "haxe",
+	hcl: "hcl",
+	hjson: "hjson",
+	hlsl: "hlsl",
+	fx: "hlsl",
+	html: "html",
+	htm: "html",
+	http: "http",
+	rest: "http",
+	hxml: "hxml",
+	hy: "hy",
+	imba: "imba",
+	ini: "ini",
+	cfg: "ini",
+	jade: "pug",
+	pug: "pug",
+	java: "java",
+	js: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	jinja: "jinja",
+	jinja2: "jinja",
+	j2: "jinja",
+	jison: "jison",
+	jl: "julia",
+	json: "json",
+	json5: "json5",
+	jsonc: "jsonc",
+	jsonl: "jsonl",
+	jsonnet: "jsonnet",
+	libsonnet: "jsonnet",
+	jssm: "jssm",
+	jsx: "jsx",
+	kt: "kotlin",
+	kts: "kts",
+	kql: "kusto",
+	tex: "tex",
+	ltx: "tex",
+	lean: "lean4",
+	less: "less",
+	liquid: "liquid",
+	lit: "lit",
+	ll: "llvm",
+	logo: "logo",
+	lua: "lua",
+	luau: "luau",
+	Makefile: "makefile",
+	mk: "makefile",
+	makefile: "makefile",
+	md: "markdown",
+	markdown: "markdown",
+	marko: "marko",
+	m: "wolfram",
+	mat: "matlab",
+	mdc: "mdc",
+	mdx: "mdx",
+	wiki: "wikitext",
+	mediawiki: "wikitext",
+	mmd: "mermaid",
+	mermaid: "mermaid",
+	mips: "mipsasm",
+	mojo: "mojo",
+	"🔥": "mojo",
+	move: "move",
+	nar: "narrat",
+	nf: "nextflow",
+	nim: "nim",
+	nims: "nim",
+	nimble: "nim",
+	nix: "nix",
+	nu: "nushell",
+	mm: "objective-cpp",
+	ml: "ocaml",
+	mli: "ocaml",
+	mll: "ocaml",
+	mly: "ocaml",
+	odin: "odin",
+	pas: "pascal",
+	p: "pascal",
+	pl: "prolog",
+	pm: "perl",
+	t: "perl",
+	raku: "raku",
+	p6: "raku",
+	pl6: "raku",
+	php: "php",
+	phtml: "php",
+	pls: "plsql",
+	sql: "sql",
+	po: "po",
+	polar: "polar",
+	pcss: "postcss",
+	pot: "pot",
+	potx: "potx",
+	pq: "powerquery",
+	pqm: "powerquery",
+	ps1: "powershell",
+	psm1: "powershell",
+	psd1: "powershell",
+	prisma: "prisma",
+	pro: "prolog",
+	P: "prolog",
+	properties: "properties",
+	proto: "protobuf",
+	pp: "puppet",
+	purs: "purescript",
+	py: "python",
+	pyw: "python",
+	pyi: "python",
+	BUCK: "python",
+	BUILD: "python",
+	PACKAGE: "python",
+	WORKSPACE: "python",
+	Tiltfile: "python",
+	bazel: "python",
+	bxl: "python",
+	bzl: "python",
+	bzlmod: "python",
+	star: "python",
+	sky: "python",
+	qml: "qml",
+	qmldir: "qmldir",
+	qss: "qss",
+	r: "r",
+	R: "r",
+	rkt: "racket",
+	rktl: "racket",
+	razor: "razor",
+	cshtml: "razor",
+	rb: "ruby",
+	rbw: "ruby",
+	reg: "reg",
+	regex: "regexp",
+	rel: "rel",
+	rs: "rust",
+	rst: "rst",
+	rake: "ruby",
+	gemspec: "ruby",
+	jbuilder: "ruby",
+	builder: "ruby",
+	rabl: "ruby",
+	arb: "ruby",
+	ru: "ruby",
+	podspec: "ruby",
+	Gemfile: "ruby",
+	Rakefile: "ruby",
+	Guardfile: "ruby",
+	Capfile: "ruby",
+	Berksfile: "ruby",
+	Brewfile: "ruby",
+	Vagrantfile: "ruby",
+	Thorfile: "ruby",
+	Appraisals: "ruby",
+	Dangerfile: "ruby",
+	sas: "sas",
+	sass: "sass",
+	scala: "scala",
+	sc: "scala",
+	scm: "scheme",
+	ss: "scheme",
+	sld: "scheme",
+	scss: "scss",
+	sdbl: "sdbl",
+	shadergraph: "shader",
+	st: "smalltalk",
+	sol: "solidity",
+	sparql: "sparql",
+	rq: "sparql",
+	spl: "splunk",
+	config: "ssh-config",
+	do: "stata",
+	ado: "stata",
+	dta: "stata",
+	styl: "stylus",
+	stylus: "stylus",
+	svelte: "svelte",
+	swift: "swift",
+	sv: "system-verilog",
+	svh: "system-verilog",
+	service: "systemd",
+	socket: "systemd",
+	device: "systemd",
+	timer: "systemd",
+	talon: "talonscript",
+	tasl: "tasl",
+	tcl: "tcl",
+	templ: "templ",
+	tf: "tf",
+	tfvars: "tfvars",
+	toml: "toml",
+	ts: "typescript",
+	mts: "typescript",
+	cts: "typescript",
+	tsp: "typespec",
+	tsv: "tsv",
+	tsx: "tsx",
+	ttl: "turtle",
+	twig: "twig",
+	typ: "typst",
+	vv: "v",
+	vala: "vala",
+	vapi: "vala",
+	vb: "vb",
+	vbs: "vb",
+	bas: "vb",
+	vh: "verilog",
+	vhd: "vhdl",
+	vhdl: "vhdl",
+	vim: "vimscript",
+	vue: "vue",
+	"vine.ts": "vue-vine",
+	vy: "vyper",
+	wasm: "wasm",
+	wat: "wasm",
+	wy: "文言",
+	wgsl: "wgsl",
+	wit: "wit",
+	wl: "wolfram",
+	nb: "wolfram",
+	xml: "xml",
+	xsl: "xsl",
+	xslt: "xsl",
+	yaml: "yaml",
+	yml: "yml",
+	zs: "zenscript",
+	zig: "zig",
+	zsh: "zsh",
+	sty: "tex"
+};
+function getFiletypeFromFileName(fileName) {
+	const format = matchFiletypeFromName(fileName);
+	if (format != null) return format;
+	const baseName = fileName.split(/[/\\]/).pop() ?? fileName;
+	return baseName === fileName ? "text" : matchFiletypeFromName(baseName) ?? "text";
+}
+function matchFiletypeFromName(fileName) {
+	if (CUSTOM_EXTENSION_TO_FILE_FORMAT.has(fileName)) return CUSTOM_EXTENSION_TO_FILE_FORMAT.get(fileName) ?? "text";
+	if (Object.hasOwn(EXTENSION_TO_FILE_FORMAT, fileName)) return EXTENSION_TO_FILE_FORMAT[fileName] ?? null;
+	const compoundMatch = fileName.match(/\.([^/\\]+\.[^/\\]+)$/);
+	if (compoundMatch != null) {
+		if (CUSTOM_EXTENSION_TO_FILE_FORMAT.has(compoundMatch[1])) return CUSTOM_EXTENSION_TO_FILE_FORMAT.get(compoundMatch[1]) ?? "text";
+		if (Object.hasOwn(EXTENSION_TO_FILE_FORMAT, compoundMatch[1])) return EXTENSION_TO_FILE_FORMAT[compoundMatch[1]] ?? "text";
+	}
+	const simpleMatch = fileName.match(/\.([^.]+)$/)?.[1] ?? "";
+	if (CUSTOM_EXTENSION_TO_FILE_FORMAT.has(simpleMatch)) return CUSTOM_EXTENSION_TO_FILE_FORMAT.get(simpleMatch) ?? "text";
+	return Object.hasOwn(EXTENSION_TO_FILE_FORMAT, simpleMatch) ? EXTENSION_TO_FILE_FORMAT[simpleMatch] ?? "text" : null;
+}
+function getCustomExtensionsVersion() {
+	return customExtensionsVersion;
+}
+function getCustomExtensionsMap() {
+	return Object.fromEntries(CUSTOM_EXTENSION_TO_FILE_FORMAT);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/getLineAnnotationName.js
+function getLineAnnotationName(annotation) {
+	return `annotation-${"side" in annotation ? `${annotation.side}-` : ""}${annotation.lineNumber}`;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+theming@1.0.1_@pierre+theme@2.0.0_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1_shiki@4.5.0/node_modules/@pierre/theming/dist/modules/color.js
+var HEX_TRANSPARENT_RE = /^#(?:[0-9a-f]{3}0|[0-9a-f]{6}00)$/i;
+var ALPHA_ZERO_RE = /^0(?:\.0+)?%?$/;
+function getFunctionalAlpha(color) {
+	const openParen = color.indexOf("(");
+	if (openParen <= 0 || !color.endsWith(")")) return;
+	const fn = color.slice(0, openParen).trim();
+	if (!/^(?:rgb|rgba|hsl|hsla|hwb|lab|lch|oklab|oklch|color)$/i.test(fn)) return;
+	const inner = color.slice(openParen + 1, -1).trim();
+	if (inner.length === 0) return;
+	const slashIndex = inner.lastIndexOf("/");
+	if (slashIndex !== -1) return inner.slice(slashIndex + 1).trim();
+	if (/^(?:rgba|hsla)$/i.test(fn)) {
+		const parts = inner.split(",");
+		if (parts.length === 4) return parts[3]?.trim();
+	}
+}
+function parseHexRgba(color) {
+	const match = /^#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})\b/i.exec(color.trim());
+	if (match == null) return null;
+	const hex = match[1];
+	let expanded;
+	let alpha = 1;
+	if (hex.length === 3) expanded = hex.split("").map((c) => c + c).join("");
+	else if (hex.length === 6) expanded = hex;
+	else {
+		expanded = hex.slice(0, 6);
+		alpha = parseInt(hex.slice(6, 8), 16) / 255;
+	}
+	return [
+		parseInt(expanded.slice(0, 2), 16),
+		parseInt(expanded.slice(2, 4), 16),
+		parseInt(expanded.slice(4, 6), 16),
+		alpha
+	];
+}
+function relativeLuminance(color) {
+	if (color == null) return null;
+	const rgba = parseHexRgba(color);
+	if (rgba == null) return null;
+	const r = rgba[0] / 255;
+	const g = rgba[1] / 255;
+	const b = rgba[2] / 255;
+	const channel = (v) => v <= .03928 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4;
+	return .2126 * channel(r) + .7152 * channel(g) + .0722 * channel(b);
+}
+function contrastRatio(a, b) {
+	const [hi, lo] = a > b ? [a, b] : [b, a];
+	return (hi + .05) / (lo + .05);
+}
+function compositeOverBg(fgColor, bgColor) {
+	if (bgColor == null) return void 0;
+	const fgParts = parseHexRgba(fgColor);
+	const bgParts = parseHexRgba(bgColor);
+	if (fgParts == null || bgParts == null) return void 0;
+	const [fr, fg, fb, fa] = fgParts;
+	const [br, bg, bb] = bgParts;
+	return "#" + [
+		Math.round(fr * fa + br * (1 - fa)),
+		Math.round(fg * fa + bg * (1 - fa)),
+		Math.round(fb * fa + bb * (1 - fa))
+	].map((v) => v.toString(16).padStart(2, "0")).join("");
+}
+function isFullyTransparent(color) {
+	if (color == null) return false;
+	const normalized = color.trim().toLowerCase();
+	if (normalized === "transparent") return true;
+	if (HEX_TRANSPARENT_RE.test(normalized)) return true;
+	const alpha = getFunctionalAlpha(normalized);
+	return alpha != null && ALPHA_ZERO_RE.test(alpha);
+}
+function isDarkSurface(bg, fgHint) {
+	const fromBg = relativeLuminance(bg);
+	if (fromBg != null) return fromBg < .4;
+	const fromFg = relativeLuminance(fgHint);
+	return fromFg != null ? fromFg > .6 : false;
+}
+function surfacesMatch(a, b) {
+	if (a == null || b == null) return false;
+	if (a.trim().toLowerCase() === b.trim().toLowerCase()) return true;
+	const la = relativeLuminance(a);
+	const lb = relativeLuminance(b);
+	if (la == null || lb == null) return false;
+	return Math.abs(la - lb) < .06;
+}
+function hoverWouldEraseText(hover, bg, fg) {
+	if (bg == null || fg == null) return false;
+	const hoverL = relativeLuminance(hover);
+	const bgL = relativeLuminance(bg);
+	const fgL = relativeLuminance(fg);
+	if (hoverL == null || bgL == null || fgL == null) return false;
+	return Math.abs(hoverL - fgL) < Math.abs(hoverL - bgL);
+}
+function pickReadableForeground(bg, candidates) {
+	const bgL = relativeLuminance(bg);
+	const firstDefined = candidates.find((candidate) => candidate != null && candidate !== "");
+	if (bgL == null) return firstDefined;
+	let best;
+	let bestRatio = -1;
+	for (const candidate of candidates) {
+		if (candidate == null || candidate === "") continue;
+		const candidateL = relativeLuminance(candidate);
+		if (candidateL == null) continue;
+		const ratio = contrastRatio(bgL, candidateL);
+		if (ratio >= 3) return candidate;
+		if (ratio > bestRatio) {
+			best = candidate;
+			bestRatio = ratio;
+		}
+	}
+	return best ?? firstDefined;
+}
+function deriveMutedFg(primaryFg, bg) {
+	if (bg == null) return primaryFg;
+	const fgParts = parseHexRgba(primaryFg);
+	const bgParts = parseHexRgba(bg);
+	const bgL = relativeLuminance(bg);
+	if (fgParts == null || bgParts == null || bgL == null) return `color-mix(in srgb, ${primaryFg} 70%, ${bg})`;
+	const [fr, fg2, fb] = fgParts;
+	const [br, bg3, bb] = bgParts;
+	for (const weight of [
+		.6,
+		.7,
+		.8,
+		.9
+	]) {
+		const hex = "#" + [
+			Math.round(fr * weight + br * (1 - weight)),
+			Math.round(fg2 * weight + bg3 * (1 - weight)),
+			Math.round(fb * weight + bb * (1 - weight))
+		].map((v) => v.toString(16).padStart(2, "0")).join("");
+		const L = relativeLuminance(hex);
+		if (L != null && contrastRatio(bgL, L) >= 4.5) return hex;
+	}
+	return primaryFg;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/computeFileOffsets.js
+var LINE_FEED = 10;
+var CARRIAGE_RETURN = 13;
+var DENSE_LINE_BREAK_BLOCK_SIZE = 4;
+var DENSE_LINE_BREAK_BLOCK_SPAN = 40;
+/**
+* Computes line start offsets for a string.
+*/
+function computeLineOffsets(contents) {
+	const offsets = [0];
+	let carriageReturn = contents.indexOf("\r");
+	let lineFeed = contents.indexOf("\n");
+	let blockStart = 0;
+	let blockBreaks = 0;
+	while (carriageReturn !== -1 || lineFeed !== -1) {
+		let nextOffset;
+		if (carriageReturn !== -1 && (lineFeed === -1 || carriageReturn < lineFeed)) {
+			if (lineFeed === carriageReturn + 1) {
+				nextOffset = lineFeed + 1;
+				carriageReturn = contents.indexOf("\r", nextOffset);
+				lineFeed = contents.indexOf("\n", nextOffset);
+			} else {
+				nextOffset = carriageReturn + 1;
+				carriageReturn = contents.indexOf("\r", nextOffset);
+			}
+		} else {
+			nextOffset = lineFeed + 1;
+			lineFeed = contents.indexOf("\n", nextOffset);
+		}
+		offsets.push(nextOffset);
+		if (++blockBreaks === DENSE_LINE_BREAK_BLOCK_SIZE) {
+			if (nextOffset - blockStart <= DENSE_LINE_BREAK_BLOCK_SPAN) {
+				for (let i = nextOffset; i < contents.length; i++) {
+					const char = contents.charCodeAt(i);
+					if (char === LINE_FEED || char === CARRIAGE_RETURN) {
+						if (char === CARRIAGE_RETURN && i + 1 < contents.length && contents.charCodeAt(i + 1) === LINE_FEED) i++;
+						offsets.push(i + 1);
+					}
+				}
+				return offsets;
+			}
+			blockStart = nextOffset;
+			blockBreaks = 0;
+		}
+	}
+	return offsets;
+}
+/**
+* Counts line breaks in a string, treating `\n`, `\r`, and `\r\n` the same way
+* {@link computeLineOffsets} does (a `\r\n` pair is one break). Mirrors that
+* scan but counts in a single pass instead of building and discarding an
+* offsets array, so sizing the changed-line range for large edits stays cheap.
+* A unit test asserts it stays in lockstep with `computeLineOffsets`.
+*/
+function countLineBreaks(contents) {
+	let count = 0;
+	for (let i = 0; i < contents.length; i++) {
+		const char = contents.charCodeAt(i);
+		if (char === LINE_FEED || char === CARRIAGE_RETURN) {
+			if (char === CARRIAGE_RETURN && i + 1 < contents.length && contents.charCodeAt(i + 1) === LINE_FEED) i++;
+			count++;
+		}
+	}
+	return count;
+}
+/**
+* Splits file contents into lines aligned with {@link computeLineOffsets}.
+* Unlike splitFileContents, a trailing newline produces a final empty line.
+*/
+function linesFromFileContents(contents) {
+	const offsets = computeLineOffsets(contents);
+	return Array.from({ length: offsets.length }, (_, i) => {
+		const start = offsets[i];
+		const end = offsets[i + 1] ?? contents.length;
+		return contents.slice(start, end);
+	});
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/lineAnnotationIdentity.js
+var lineAnnotationSources = /* @__PURE__ */ new WeakMap();
+/**
+* Resolve a possibly-remapped annotation back to the original object it
+* descends from. Annotations that were never cloned resolve to themselves.
+*/
+function getLineAnnotationSource(annotation) {
+	const source = lineAnnotationSources.get(annotation);
+	return source == null ? annotation : source;
+}
+function recordLineAnnotationSource(moved, annotation) {
+	lineAnnotationSources.set(moved, annotation);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/platform.js
+var _isMacLike = void 0;
+var _isSafari = void 0;
+var _isFirefox = void 0;
+function isMacLike() {
+	return _isMacLike ??= /macOS|MacIntel|iPhone|iPad|iPod/i.test(getPlatform());
+}
+function isSafari() {
+	return _isSafari ??= "safari" in window && "pushNotification" in window.safari || /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+}
+function isFirefox() {
+	return _isFirefox ??= /\bFirefox\//.test(navigator.userAgent);
+}
+function getPlatform() {
+	const navigator = globalThis.navigator;
+	return navigator?.platform ?? navigator?.userAgentData?.platform ?? "unknown";
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@pierre+diffs@1.5.2_@shikijs+themes@4.5.0_react-dom@19.3.1_react@19.3.1__react@19.3.1/node_modules/@pierre/diffs/dist/utils/cloneFileDiffMetadata.js
+function cloneHunks(hunks) {
+	return hunks.map((hunk) => ({
+		...hunk,
+		hunkContent: hunk.hunkContent.map((content) => ({ ...content }))
+	}));
+}
+function cloneFileDiffMetadata(fileDiff) {
+	return {
+		...fileDiff,
+		hunks: cloneHunks(fileDiff.hunks),
+		deletionLines: [...fileDiff.deletionLines],
+		additionLines: [...fileDiff.additionLines]
+	};
+}
+//#endregion
+export { INDEX_LINE_METADATA as $, Registry as A, DEFAULT_THEMES as B, getFiletypeFromFileName as C, EncodedTokenMetadata as D, queueRender as E, DEFAULT_CODE_VIEW_FILE_METRICS as F, DIFFS_SCROLLBAR_MEASURE_ATTRIBUTE as G, DEFAULT_VIRTUAL_FILE_METRICS as H, DEFAULT_CODE_VIEW_LAYOUT as I, FILENAME_HEADER_REGEX as J, DIFFS_TAG_NAME as K, DEFAULT_EXPANDED_REGION as L, CODE_VIEW_FOOTER_ATTRIBUTE as M, CODE_VIEW_HEADER_ATTRIBUTE as N, FontStyle as O, CUSTOM_HEADER_SLOT_ID as P, HEADER_PREFIX_SLOT_ID as Q, DEFAULT_RENDER_RANGE as R, getCustomExtensionsVersion as S, dequeueRender as T, DIFFS_DEVELOPMENT_BUILD as U, DEFAULT_TOKENIZE_MAX_LENGTH as V, DIFFS_SCROLLBAR_GUTTER_MEASURED_PROPERTY as W, HEADER_FILENAME_SUFFIX_SLOT_ID as X, GIT_DIFF_FILE_BREAK_REGEX as Y, HEADER_METADATA_SLOT_ID as Z, pickReadableForeground as _, isSafari as a, getLineAnnotationName as b, computeLineOffsets as c, compositeOverBg as d, SPLIT_WITH_NEWLINES as et, contrastRatio as f, isFullyTransparent as g, isDarkSurface as h, isMacLike as i, Theme as j, INITIAL as k, countLineBreaks as l, hoverWouldEraseText as m, cloneHunks as n, UNSAFE_CSS_ATTRIBUTE as nt, getLineAnnotationSource as o, deriveMutedFg as p, EMPTY_RENDER_RANGE as q, isFirefox as r, recordLineAnnotationSource as s, cloneFileDiffMetadata as t, THEME_CSS_ATTRIBUTE as tt, linesFromFileContents as u, relativeLuminance as v, isGutterUtilityPath as w, getCustomExtensionsMap as x, surfacesMatch as y, DEFAULT_SMOOTH_SCROLL_SETTINGS as z };