@veltra/desktop 1.2.16 → 1.2.18

package/dist/node_modules/.bun/@codemirror_language@6.12.4/node_modules/@codemirror/language/dist/index.js

@@ -0,0 +1,1767 @@
+import { IterMode, NodeProp, NodeType, Parser, Tree, TreeFragment } from "../../../../../@lezer_common@1.5.2/node_modules/@lezer/common/dist/index.js";
+import { highlightTree, styleTags, tagHighlighter, tags } from "../../../../../@lezer_highlight@1.2.3/node_modules/@lezer/highlight/dist/index.js";
+import { EditorState, Facet, Prec, RangeSet, RangeSetBuilder, StateEffect, StateField, combineConfig, countColumn } from "../../../../../@codemirror_state@6.7.0/node_modules/@codemirror/state/dist/index.js";
+import { StyleModule } from "../../../../../style-mod@4.1.3/node_modules/style-mod/src/style-mod.js";
+import { Decoration, Direction, EditorView, GutterMarker, ViewPlugin, WidgetType, gutter, logException } from "../../../../../@codemirror_view@6.43.4/node_modules/@codemirror/view/dist/index.js";
+//#region ../../node_modules/.bun/@codemirror+language@6.12.4/node_modules/@codemirror/language/dist/index.js
+var _a;
+/**
+Node prop stored in a parser's top syntax node to provide the
+facet that stores language-specific data for that language.
+*/
+const languageDataProp = /*@__PURE__*/ new NodeProp();
+/**
+Helper function to define a facet (to be added to the top syntax
+node(s) for a language via
+[`languageDataProp`](https://codemirror.net/6/docs/ref/#language.languageDataProp)), that will be
+used to associate language data with the language. You
+probably only need this when subclassing
+[`Language`](https://codemirror.net/6/docs/ref/#language.Language).
+*/
+function defineLanguageFacet(baseData) {
+	return Facet.define({ combine: baseData ? (values) => values.concat(baseData) : void 0 });
+}
+/**
+Syntax node prop used to register sublanguages. Should be added to
+the top level node type for the language.
+*/
+const sublanguageProp = /*@__PURE__*/ new NodeProp();
+/**
+A language object manages parsing and per-language
+[metadata](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt). Parse data is
+managed as a [Lezer](https://lezer.codemirror.net) tree. The class
+can be used directly, via the [`LRLanguage`](https://codemirror.net/6/docs/ref/#language.LRLanguage)
+subclass for [Lezer](https://lezer.codemirror.net/) LR parsers, or
+via the [`StreamLanguage`](https://codemirror.net/6/docs/ref/#language.StreamLanguage) subclass
+for stream parsers.
+*/
+var Language = class {
+	/**
+	Construct a language object. If you need to invoke this
+	directly, first define a data facet with
+	[`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet), and then
+	configure your parser to [attach](https://codemirror.net/6/docs/ref/#language.languageDataProp) it
+	to the language's outer syntax node.
+	*/
+	constructor(data, parser, extraExtensions = [], name = "") {
+		this.data = data;
+		this.name = name;
+		if (!EditorState.prototype.hasOwnProperty("tree")) Object.defineProperty(EditorState.prototype, "tree", { get() {
+			return syntaxTree(this);
+		} });
+		this.parser = parser;
+		this.extension = [language.of(this), EditorState.languageData.of((state, pos, side) => {
+			let top = topNodeAt(state, pos, side), data = top.type.prop(languageDataProp);
+			if (!data) return [];
+			let base = state.facet(data), sub = top.type.prop(sublanguageProp);
+			if (sub) {
+				let innerNode = top.resolve(pos - top.from, side);
+				for (let sublang of sub) if (sublang.test(innerNode, state)) {
+					let data = state.facet(sublang.facet);
+					return sublang.type == "replace" ? data : data.concat(base);
+				}
+			}
+			return base;
+		})].concat(extraExtensions);
+	}
+	/**
+	Query whether this language is active at the given position.
+	*/
+	isActiveAt(state, pos, side = -1) {
+		return topNodeAt(state, pos, side).type.prop(languageDataProp) == this.data;
+	}
+	/**
+	Find the document regions that were parsed using this language.
+	The returned regions will _include_ any nested languages rooted
+	in this language, when those exist.
+	*/
+	findRegions(state) {
+		let lang = state.facet(language);
+		if ((lang === null || lang === void 0 ? void 0 : lang.data) == this.data) return [{
+			from: 0,
+			to: state.doc.length
+		}];
+		if (!lang || !lang.allowsNesting) return [];
+		let result = [];
+		let explore = (tree, from) => {
+			if (tree.prop(languageDataProp) == this.data) {
+				result.push({
+					from,
+					to: from + tree.length
+				});
+				return;
+			}
+			let mount = tree.prop(NodeProp.mounted);
+			if (mount) {
+				if (mount.tree.prop(languageDataProp) == this.data) {
+					if (mount.overlay) for (let r of mount.overlay) result.push({
+						from: r.from + from,
+						to: r.to + from
+					});
+					else result.push({
+						from,
+						to: from + tree.length
+					});
+					return;
+				} else if (mount.overlay) {
+					let size = result.length;
+					explore(mount.tree, mount.overlay[0].from + from);
+					if (result.length > size) return;
+				}
+			}
+			for (let i = 0; i < tree.children.length; i++) {
+				let ch = tree.children[i];
+				if (ch instanceof Tree) explore(ch, tree.positions[i] + from);
+			}
+		};
+		explore(syntaxTree(state), 0);
+		return result;
+	}
+	/**
+	Indicates whether this language allows nested languages. The
+	default implementation returns true.
+	*/
+	get allowsNesting() {
+		return true;
+	}
+};
+/**
+@internal
+*/
+Language.setState = /*@__PURE__*/ StateEffect.define();
+function topNodeAt(state, pos, side) {
+	let topLang = state.facet(language), tree = syntaxTree(state).topNode;
+	if (!topLang || topLang.allowsNesting) {
+		for (let node = tree; node; node = node.enter(pos, side, IterMode.ExcludeBuffers | IterMode.EnterBracketed)) if (node.type.isTop) tree = node;
+	}
+	return tree;
+}
+/**
+A subclass of [`Language`](https://codemirror.net/6/docs/ref/#language.Language) for use with Lezer
+[LR parsers](https://lezer.codemirror.net/docs/ref#lr.LRParser).
+*/
+var LRLanguage = class LRLanguage extends Language {
+	constructor(data, parser, name) {
+		super(data, parser, [], name);
+		this.parser = parser;
+	}
+	/**
+	Define a language from a parser.
+	*/
+	static define(spec) {
+		let data = defineLanguageFacet(spec.languageData);
+		return new LRLanguage(data, spec.parser.configure({ props: [languageDataProp.add((type) => type.isTop ? data : void 0)] }), spec.name);
+	}
+	/**
+	Create a new instance of this language with a reconfigured
+	version of its parser and optionally a new name.
+	*/
+	configure(options, name) {
+		return new LRLanguage(this.data, this.parser.configure(options), name || this.name);
+	}
+	get allowsNesting() {
+		return this.parser.hasWrappers();
+	}
+};
+/**
+Get the syntax tree for a state, which is the current (possibly
+incomplete) parse tree of the active
+[language](https://codemirror.net/6/docs/ref/#language.Language), or the empty tree if there is no
+language available.
+*/
+function syntaxTree(state) {
+	let field = state.field(Language.state, false);
+	return field ? field.tree : Tree.empty;
+}
+/**
+Lezer-style
+[`Input`](https://lezer.codemirror.net/docs/ref#common.Input)
+object for a [`Text`](https://codemirror.net/6/docs/ref/#state.Text) object.
+*/
+var DocInput = class {
+	/**
+	Create an input object for the given document.
+	*/
+	constructor(doc) {
+		this.doc = doc;
+		this.cursorPos = 0;
+		this.string = "";
+		this.cursor = doc.iter();
+	}
+	get length() {
+		return this.doc.length;
+	}
+	syncTo(pos) {
+		this.string = this.cursor.next(pos - this.cursorPos).value;
+		this.cursorPos = pos + this.string.length;
+		return this.cursorPos - this.string.length;
+	}
+	chunk(pos) {
+		this.syncTo(pos);
+		return this.string;
+	}
+	get lineChunks() {
+		return true;
+	}
+	read(from, to) {
+		let stringStart = this.cursorPos - this.string.length;
+		if (from < stringStart || to >= this.cursorPos) return this.doc.sliceString(from, to);
+		else return this.string.slice(from - stringStart, to - stringStart);
+	}
+};
+let currentContext = null;
+/**
+A parse context provided to parsers working on the editor content.
+*/
+var ParseContext = class ParseContext {
+	constructor(parser, state, fragments = [], tree, treeLen, viewport, skipped, scheduleOn) {
+		this.parser = parser;
+		this.state = state;
+		this.fragments = fragments;
+		this.tree = tree;
+		this.treeLen = treeLen;
+		this.viewport = viewport;
+		this.skipped = skipped;
+		this.scheduleOn = scheduleOn;
+		this.parse = null;
+		/**
+		@internal
+		*/
+		this.tempSkipped = [];
+	}
+	/**
+	@internal
+	*/
+	static create(parser, state, viewport) {
+		return new ParseContext(parser, state, [], Tree.empty, 0, viewport, [], null);
+	}
+	startParse() {
+		return this.parser.startParse(new DocInput(this.state.doc), this.fragments);
+	}
+	/**
+	@internal
+	*/
+	work(until, upto) {
+		if (upto != null && upto >= this.state.doc.length) upto = void 0;
+		if (this.tree != Tree.empty && this.isDone(upto !== null && upto !== void 0 ? upto : this.state.doc.length)) {
+			this.takeTree();
+			return true;
+		}
+		return this.withContext(() => {
+			var _a;
+			if (typeof until == "number") {
+				let endTime = Date.now() + until;
+				until = () => Date.now() > endTime;
+			}
+			if (!this.parse) this.parse = this.startParse();
+			if (upto != null && (this.parse.stoppedAt == null || this.parse.stoppedAt > upto) && upto < this.state.doc.length) this.parse.stopAt(upto);
+			for (;;) {
+				let done = this.parse.advance();
+				if (done) {
+					this.fragments = this.withoutTempSkipped(TreeFragment.addTree(done, this.fragments, this.parse.stoppedAt != null));
+					this.treeLen = (_a = this.parse.stoppedAt) !== null && _a !== void 0 ? _a : this.state.doc.length;
+					this.tree = done;
+					this.parse = null;
+					if (this.treeLen < (upto !== null && upto !== void 0 ? upto : this.state.doc.length)) this.parse = this.startParse();
+					else return true;
+				}
+				if (until()) return false;
+			}
+		});
+	}
+	/**
+	@internal
+	*/
+	takeTree() {
+		let pos, tree;
+		if (this.parse && (pos = this.parse.parsedPos) >= this.treeLen) {
+			if (this.parse.stoppedAt == null || this.parse.stoppedAt > pos) this.parse.stopAt(pos);
+			this.withContext(() => {
+				while (!(tree = this.parse.advance()));
+			});
+			this.treeLen = pos;
+			this.tree = tree;
+			this.fragments = this.withoutTempSkipped(TreeFragment.addTree(this.tree, this.fragments, true));
+			this.parse = null;
+		}
+	}
+	withContext(f) {
+		let prev = currentContext;
+		currentContext = this;
+		try {
+			return f();
+		} finally {
+			currentContext = prev;
+		}
+	}
+	withoutTempSkipped(fragments) {
+		for (let r; r = this.tempSkipped.pop();) fragments = cutFragments(fragments, r.from, r.to);
+		return fragments;
+	}
+	/**
+	@internal
+	*/
+	changes(changes, newState) {
+		let { fragments, tree, treeLen, viewport, skipped } = this;
+		this.takeTree();
+		if (!changes.empty) {
+			let ranges = [];
+			changes.iterChangedRanges((fromA, toA, fromB, toB) => ranges.push({
+				fromA,
+				toA,
+				fromB,
+				toB
+			}));
+			fragments = TreeFragment.applyChanges(fragments, ranges);
+			tree = Tree.empty;
+			treeLen = 0;
+			viewport = {
+				from: changes.mapPos(viewport.from, -1),
+				to: changes.mapPos(viewport.to, 1)
+			};
+			if (this.skipped.length) {
+				skipped = [];
+				for (let r of this.skipped) {
+					let from = changes.mapPos(r.from, 1), to = changes.mapPos(r.to, -1);
+					if (from < to) skipped.push({
+						from,
+						to
+					});
+				}
+			}
+		}
+		return new ParseContext(this.parser, newState, fragments, tree, treeLen, viewport, skipped, this.scheduleOn);
+	}
+	/**
+	@internal
+	*/
+	updateViewport(viewport) {
+		if (this.viewport.from == viewport.from && this.viewport.to == viewport.to) return false;
+		this.viewport = viewport;
+		let startLen = this.skipped.length;
+		for (let i = 0; i < this.skipped.length; i++) {
+			let { from, to } = this.skipped[i];
+			if (from < viewport.to && to > viewport.from) {
+				this.fragments = cutFragments(this.fragments, from, to);
+				this.skipped.splice(i--, 1);
+			}
+		}
+		if (this.skipped.length >= startLen) return false;
+		this.reset();
+		return true;
+	}
+	/**
+	@internal
+	*/
+	reset() {
+		if (this.parse) {
+			this.takeTree();
+			this.parse = null;
+		}
+	}
+	/**
+	Notify the parse scheduler that the given region was skipped
+	because it wasn't in view, and the parse should be restarted
+	when it comes into view.
+	*/
+	skipUntilInView(from, to) {
+		this.skipped.push({
+			from,
+			to
+		});
+	}
+	/**
+	Returns a parser intended to be used as placeholder when
+	asynchronously loading a nested parser. It'll skip its input and
+	mark it as not-really-parsed, so that the next update will parse
+	it again.
+	
+	When `until` is given, a reparse will be scheduled when that
+	promise resolves.
+	*/
+	static getSkippingParser(until) {
+		return new class extends Parser {
+			createParse(input, fragments, ranges) {
+				let from = ranges[0].from, to = ranges[ranges.length - 1].to;
+				return {
+					parsedPos: from,
+					advance() {
+						let cx = currentContext;
+						if (cx) {
+							for (let r of ranges) cx.tempSkipped.push(r);
+							if (until) cx.scheduleOn = cx.scheduleOn ? Promise.all([cx.scheduleOn, until]) : until;
+						}
+						this.parsedPos = to;
+						return new Tree(NodeType.none, [], [], to - from);
+					},
+					stoppedAt: null,
+					stopAt() {}
+				};
+			}
+		}();
+	}
+	/**
+	@internal
+	*/
+	isDone(upto) {
+		upto = Math.min(upto, this.state.doc.length);
+		let frags = this.fragments;
+		return this.treeLen >= upto && frags.length && frags[0].from == 0 && frags[0].to >= upto;
+	}
+	/**
+	Get the context for the current parse, or `null` if no editor
+	parse is in progress.
+	*/
+	static get() {
+		return currentContext;
+	}
+};
+function cutFragments(fragments, from, to) {
+	return TreeFragment.applyChanges(fragments, [{
+		fromA: from,
+		toA: to,
+		fromB: from,
+		toB: to
+	}]);
+}
+var LanguageState = class LanguageState {
+	constructor(context) {
+		this.context = context;
+		this.tree = context.tree;
+	}
+	apply(tr) {
+		if (!tr.docChanged && this.tree == this.context.tree) return this;
+		let newCx = this.context.changes(tr.changes, tr.state);
+		let upto = this.context.treeLen == tr.startState.doc.length ? void 0 : Math.max(tr.changes.mapPos(this.context.treeLen), newCx.viewport.to);
+		if (!newCx.work(20, upto)) newCx.takeTree();
+		return new LanguageState(newCx);
+	}
+	static init(state) {
+		let vpTo = Math.min(3e3, state.doc.length);
+		let parseState = ParseContext.create(state.facet(language).parser, state, {
+			from: 0,
+			to: vpTo
+		});
+		if (!parseState.work(20, vpTo)) parseState.takeTree();
+		return new LanguageState(parseState);
+	}
+};
+Language.state = /*@__PURE__*/ StateField.define({
+	create: LanguageState.init,
+	update(value, tr) {
+		for (let e of tr.effects) if (e.is(Language.setState)) return e.value;
+		if (tr.startState.facet(language) != tr.state.facet(language)) return LanguageState.init(tr.state);
+		return value.apply(tr);
+	}
+});
+let requestIdle = (callback) => {
+	let timeout = setTimeout(() => callback(), 500);
+	return () => clearTimeout(timeout);
+};
+if (typeof requestIdleCallback != "undefined") requestIdle = (callback) => {
+	let idle = -1, timeout = setTimeout(() => {
+		idle = requestIdleCallback(callback, { timeout: 400 });
+	}, 100);
+	return () => idle < 0 ? clearTimeout(timeout) : cancelIdleCallback(idle);
+};
+const isInputPending = typeof navigator != "undefined" && ((_a = navigator.scheduling) === null || _a === void 0 ? void 0 : _a.isInputPending) ? () => navigator.scheduling.isInputPending() : null;
+const parseWorker = /*@__PURE__*/ ViewPlugin.fromClass(class ParseWorker {
+	constructor(view) {
+		this.view = view;
+		this.working = null;
+		this.workScheduled = 0;
+		this.chunkEnd = -1;
+		this.chunkBudget = -1;
+		this.work = this.work.bind(this);
+		this.scheduleWork();
+	}
+	update(update) {
+		let cx = this.view.state.field(Language.state).context;
+		if (cx.updateViewport(update.view.viewport) || this.view.viewport.to > cx.treeLen) this.scheduleWork();
+		if (update.docChanged || update.selectionSet) {
+			if (this.view.hasFocus) this.chunkBudget += 50;
+			this.scheduleWork();
+		}
+		this.checkAsyncSchedule(cx);
+	}
+	scheduleWork() {
+		if (this.working) return;
+		let { state } = this.view, field = state.field(Language.state);
+		if (field.tree != field.context.tree || !field.context.isDone(state.doc.length)) this.working = requestIdle(this.work);
+	}
+	work(deadline) {
+		this.working = null;
+		let now = Date.now();
+		if (this.chunkEnd < now && (this.chunkEnd < 0 || this.view.hasFocus)) {
+			this.chunkEnd = now + 3e4;
+			this.chunkBudget = 3e3;
+		}
+		if (this.chunkBudget <= 0) return;
+		let { state, viewport: { to: vpTo } } = this.view, field = state.field(Language.state);
+		if (field.tree == field.context.tree && field.context.isDone(vpTo + 1e5)) return;
+		let endTime = Date.now() + Math.min(this.chunkBudget, 100, deadline && !isInputPending ? Math.max(25, deadline.timeRemaining() - 5) : 1e9);
+		let viewportFirst = field.context.treeLen < vpTo && state.doc.length > vpTo + 1e3;
+		let done = field.context.work(() => {
+			return isInputPending && isInputPending() || Date.now() > endTime;
+		}, vpTo + (viewportFirst ? 0 : 1e5));
+		this.chunkBudget -= Date.now() - now;
+		if (done || this.chunkBudget <= 0) {
+			field.context.takeTree();
+			this.view.dispatch({ effects: Language.setState.of(new LanguageState(field.context)) });
+		}
+		if (this.chunkBudget > 0 && !(done && !viewportFirst)) this.scheduleWork();
+		this.checkAsyncSchedule(field.context);
+	}
+	checkAsyncSchedule(cx) {
+		if (cx.scheduleOn) {
+			this.workScheduled++;
+			cx.scheduleOn.then(() => this.scheduleWork()).catch((err) => logException(this.view.state, err)).then(() => this.workScheduled--);
+			cx.scheduleOn = null;
+		}
+	}
+	destroy() {
+		if (this.working) this.working();
+	}
+	isWorking() {
+		return !!(this.working || this.workScheduled > 0);
+	}
+}, { eventHandlers: { focus() {
+	this.scheduleWork();
+} } });
+/**
+The facet used to associate a language with an editor state. Used
+by `Language` object's `extension` property (so you don't need to
+manually wrap your languages in this). Can be used to access the
+current language on a state.
+*/
+const language = /*@__PURE__*/ Facet.define({
+	combine(languages) {
+		return languages.length ? languages[0] : null;
+	},
+	enables: (language) => [
+		Language.state,
+		parseWorker,
+		EditorView.contentAttributes.compute([language], (state) => {
+			let lang = state.facet(language);
+			return lang && lang.name ? { "data-language": lang.name } : {};
+		})
+	]
+});
+/**
+This class bundles a [language](https://codemirror.net/6/docs/ref/#language.Language) with an
+optional set of supporting extensions. Language packages are
+encouraged to export a function that optionally takes a
+configuration object and returns a `LanguageSupport` instance, as
+the main way for client code to use the package.
+*/
+var LanguageSupport = class {
+	/**
+	Create a language support object.
+	*/
+	constructor(language, support = []) {
+		this.language = language;
+		this.support = support;
+		this.extension = [language, support];
+	}
+};
+/**
+Facet that defines a way to provide a function that computes the
+appropriate indentation depth, as a column number (see
+[`indentString`](https://codemirror.net/6/docs/ref/#language.indentString)), at the start of a given
+line. A return value of `null` indicates no indentation can be
+determined, and the line should inherit the indentation of the one
+above it. A return value of `undefined` defers to the next indent
+service.
+*/
+const indentService = /*@__PURE__*/ Facet.define();
+/**
+Facet for overriding the unit by which indentation happens. Should
+be a string consisting entirely of the same whitespace character.
+When not set, this defaults to 2 spaces.
+*/
+const indentUnit = /*@__PURE__*/ Facet.define({ combine: (values) => {
+	if (!values.length) return "  ";
+	let unit = values[0];
+	if (!unit || /\S/.test(unit) || Array.from(unit).some((e) => e != unit[0])) throw new Error("Invalid indent unit: " + JSON.stringify(values[0]));
+	return unit;
+} });
+/**
+Return the _column width_ of an indent unit in the state.
+Determined by the [`indentUnit`](https://codemirror.net/6/docs/ref/#language.indentUnit)
+facet, and [`tabSize`](https://codemirror.net/6/docs/ref/#state.EditorState^tabSize) when that
+contains tabs.
+*/
+function getIndentUnit(state) {
+	let unit = state.facet(indentUnit);
+	return unit.charCodeAt(0) == 9 ? state.tabSize * unit.length : unit.length;
+}
+/**
+Create an indentation string that covers columns 0 to `cols`.
+Will use tabs for as much of the columns as possible when the
+[`indentUnit`](https://codemirror.net/6/docs/ref/#language.indentUnit) facet contains
+tabs.
+*/
+function indentString(state, cols) {
+	let result = "", ts = state.tabSize, ch = state.facet(indentUnit)[0];
+	if (ch == "	") {
+		while (cols >= ts) {
+			result += "	";
+			cols -= ts;
+		}
+		ch = " ";
+	}
+	for (let i = 0; i < cols; i++) result += ch;
+	return result;
+}
+/**
+Get the indentation, as a column number, at the given position.
+Will first consult any [indent services](https://codemirror.net/6/docs/ref/#language.indentService)
+that are registered, and if none of those return an indentation,
+this will check the syntax tree for the [indent node
+prop](https://codemirror.net/6/docs/ref/#language.indentNodeProp) and use that if found. Returns a
+number when an indentation could be determined, and null
+otherwise.
+*/
+function getIndentation(context, pos) {
+	if (context instanceof EditorState) context = new IndentContext(context);
+	for (let service of context.state.facet(indentService)) {
+		let result = service(context, pos);
+		if (result !== void 0) return result;
+	}
+	let tree = syntaxTree(context.state);
+	return tree.length >= pos ? syntaxIndentation(context, tree, pos) : null;
+}
+/**
+Indentation contexts are used when calling [indentation
+services](https://codemirror.net/6/docs/ref/#language.indentService). They provide helper utilities
+useful in indentation logic, and can selectively override the
+indentation reported for some lines.
+*/
+var IndentContext = class {
+	/**
+	Create an indent context.
+	*/
+	constructor(state, options = {}) {
+		this.state = state;
+		this.options = options;
+		this.unit = getIndentUnit(state);
+	}
+	/**
+	Get a description of the line at the given position, taking
+	[simulated line
+	breaks](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+	into account. If there is such a break at `pos`, the `bias`
+	argument determines whether the part of the line line before or
+	after the break is used.
+	*/
+	lineAt(pos, bias = 1) {
+		let line = this.state.doc.lineAt(pos);
+		let { simulateBreak, simulateDoubleBreak } = this.options;
+		if (simulateBreak != null && simulateBreak >= line.from && simulateBreak <= line.to) if (simulateDoubleBreak && simulateBreak == pos) return {
+			text: "",
+			from: pos
+		};
+		else if (bias < 0 ? simulateBreak < pos : simulateBreak <= pos) return {
+			text: line.text.slice(simulateBreak - line.from),
+			from: simulateBreak
+		};
+		else return {
+			text: line.text.slice(0, simulateBreak - line.from),
+			from: line.from
+		};
+		return line;
+	}
+	/**
+	Get the text directly after `pos`, either the entire line
+	or the next 100 characters, whichever is shorter.
+	*/
+	textAfterPos(pos, bias = 1) {
+		if (this.options.simulateDoubleBreak && pos == this.options.simulateBreak) return "";
+		let { text, from } = this.lineAt(pos, bias);
+		return text.slice(pos - from, Math.min(text.length, pos + 100 - from));
+	}
+	/**
+	Find the column for the given position.
+	*/
+	column(pos, bias = 1) {
+		let { text, from } = this.lineAt(pos, bias);
+		let result = this.countColumn(text, pos - from);
+		let override = this.options.overrideIndentation ? this.options.overrideIndentation(from) : -1;
+		if (override > -1) result += override - this.countColumn(text, text.search(/\S|$/));
+		return result;
+	}
+	/**
+	Find the column position (taking tabs into account) of the given
+	position in the given string.
+	*/
+	countColumn(line, pos = line.length) {
+		return countColumn(line, this.state.tabSize, pos);
+	}
+	/**
+	Find the indentation column of the line at the given point.
+	*/
+	lineIndent(pos, bias = 1) {
+		let { text, from } = this.lineAt(pos, bias);
+		let override = this.options.overrideIndentation;
+		if (override) {
+			let overriden = override(from);
+			if (overriden > -1) return overriden;
+		}
+		return this.countColumn(text, text.search(/\S|$/));
+	}
+	/**
+	Returns the [simulated line
+	break](https://codemirror.net/6/docs/ref/#language.IndentContext.constructor^options.simulateBreak)
+	for this context, if any.
+	*/
+	get simulatedBreak() {
+		return this.options.simulateBreak || null;
+	}
+};
+/**
+A syntax tree node prop used to associate indentation strategies
+with node types. Such a strategy is a function from an indentation
+context to a column number (see also
+[`indentString`](https://codemirror.net/6/docs/ref/#language.indentString)) or null, where null
+indicates that no definitive indentation can be determined.
+*/
+const indentNodeProp = /*@__PURE__*/ new NodeProp();
+function syntaxIndentation(cx, ast, pos) {
+	let stack = ast.resolveStack(pos);
+	let inner = ast.resolveInner(pos, -1).resolve(pos, 0).enterUnfinishedNodesBefore(pos);
+	if (inner != stack.node) {
+		let add = [];
+		for (let cur = inner; cur && !(cur.from < stack.node.from || cur.to > stack.node.to || cur.from == stack.node.from && cur.type == stack.node.type); cur = cur.parent) add.push(cur);
+		for (let i = add.length - 1; i >= 0; i--) stack = {
+			node: add[i],
+			next: stack
+		};
+	}
+	return indentFor(stack, cx, pos);
+}
+function indentFor(stack, cx, pos) {
+	for (let cur = stack; cur; cur = cur.next) {
+		let strategy = indentStrategy(cur.node);
+		if (strategy) return strategy(TreeIndentContext.create(cx, pos, cur));
+	}
+	return 0;
+}
+function ignoreClosed(cx) {
+	return cx.pos == cx.options.simulateBreak && cx.options.simulateDoubleBreak;
+}
+function indentStrategy(tree) {
+	let strategy = tree.type.prop(indentNodeProp);
+	if (strategy) return strategy;
+	let first = tree.firstChild, close;
+	if (first && (close = first.type.prop(NodeProp.closedBy))) {
+		let last = tree.lastChild, closed = last && close.indexOf(last.name) > -1;
+		return (cx) => delimitedStrategy(cx, true, 1, void 0, closed && !ignoreClosed(cx) ? last.from : void 0);
+	}
+	return tree.parent == null ? topIndent : null;
+}
+function topIndent() {
+	return 0;
+}
+/**
+Objects of this type provide context information and helper
+methods to indentation functions registered on syntax nodes.
+*/
+var TreeIndentContext = class TreeIndentContext extends IndentContext {
+	constructor(base, pos, context) {
+		super(base.state, base.options);
+		this.base = base;
+		this.pos = pos;
+		this.context = context;
+	}
+	/**
+	The syntax tree node to which the indentation strategy
+	applies.
+	*/
+	get node() {
+		return this.context.node;
+	}
+	/**
+	@internal
+	*/
+	static create(base, pos, context) {
+		return new TreeIndentContext(base, pos, context);
+	}
+	/**
+	Get the text directly after `this.pos`, either the entire line
+	or the next 100 characters, whichever is shorter.
+	*/
+	get textAfter() {
+		return this.textAfterPos(this.pos);
+	}
+	/**
+	Get the indentation at the reference line for `this.node`, which
+	is the line on which it starts, unless there is a node that is
+	_not_ a parent of this node covering the start of that line. If
+	so, the line at the start of that node is tried, again skipping
+	on if it is covered by another such node.
+	*/
+	get baseIndent() {
+		return this.baseIndentFor(this.node);
+	}
+	/**
+	Get the indentation for the reference line of the given node
+	(see [`baseIndent`](https://codemirror.net/6/docs/ref/#language.TreeIndentContext.baseIndent)).
+	*/
+	baseIndentFor(node) {
+		let line = this.state.doc.lineAt(node.from);
+		for (;;) {
+			let atBreak = node.resolve(line.from);
+			while (atBreak.parent && atBreak.parent.from == atBreak.from) atBreak = atBreak.parent;
+			if (isParent(atBreak, node)) break;
+			line = this.state.doc.lineAt(atBreak.from);
+		}
+		return this.lineIndent(line.from);
+	}
+	/**
+	Continue looking for indentations in the node's parent nodes,
+	and return the result of that.
+	*/
+	continue() {
+		return indentFor(this.context.next, this.base, this.pos);
+	}
+};
+function isParent(parent, of) {
+	for (let cur = of; cur; cur = cur.parent) if (parent == cur) return true;
+	return false;
+}
+function bracketedAligned(context) {
+	let tree = context.node;
+	let openToken = tree.childAfter(tree.from), last = tree.lastChild;
+	if (!openToken) return null;
+	let sim = context.options.simulateBreak;
+	let openLine = context.state.doc.lineAt(openToken.from);
+	let lineEnd = sim == null || sim <= openLine.from ? openLine.to : Math.min(openLine.to, sim);
+	for (let pos = openToken.to;;) {
+		let next = tree.childAfter(pos);
+		if (!next || next == last) return null;
+		if (!next.type.isSkipped) {
+			if (next.from >= lineEnd) return null;
+			let space = /^ */.exec(openLine.text.slice(openToken.to - openLine.from))[0].length;
+			return {
+				from: openToken.from,
+				to: openToken.to + space
+			};
+		}
+		pos = next.to;
+	}
+}
+/**
+An indentation strategy for delimited (usually bracketed) nodes.
+Will, by default, indent one unit more than the parent's base
+indent unless the line starts with a closing token. When `align`
+is true and there are non-skipped nodes on the node's opening
+line, the content of the node will be aligned with the end of the
+opening node, like this:
+
+foo(bar,
+baz)
+*/
+function delimitedIndent({ closing, align = true, units = 1 }) {
+	return (context) => delimitedStrategy(context, align, units, closing);
+}
+function delimitedStrategy(context, align, units, closing, closedAt) {
+	let after = context.textAfter, space = after.match(/^\s*/)[0].length;
+	let closed = closing && after.slice(space, space + closing.length) == closing || closedAt == context.pos + space;
+	let aligned = align ? bracketedAligned(context) : null;
+	if (aligned) return closed ? context.column(aligned.from) : context.column(aligned.to);
+	return context.baseIndent + (closed ? 0 : context.unit * units);
+}
+/**
+An indentation strategy that aligns a node's content to its base
+indentation.
+*/
+const flatIndent = (context) => context.baseIndent;
+/**
+Creates an indentation strategy that, by default, indents
+continued lines one unit more than the node's base indentation.
+You can provide `except` to prevent indentation of lines that
+match a pattern (for example `/^else\b/` in `if`/`else`
+constructs), and you can change the amount of units used with the
+`units` option.
+*/
+function continuedIndent({ except, units = 1 } = {}) {
+	return (context) => {
+		let matchExcept = except && except.test(context.textAfter);
+		return context.baseIndent + (matchExcept ? 0 : units * context.unit);
+	};
+}
+const DontIndentBeyond = 200;
+/**
+Enables reindentation on input. When a language defines an
+`indentOnInput` field in its [language
+data](https://codemirror.net/6/docs/ref/#state.EditorState.languageDataAt), which must hold a regular
+expression, the line at the cursor will be reindented whenever new
+text is typed and the input from the start of the line up to the
+cursor matches that regexp.
+
+To avoid unneccesary reindents, it is recommended to start the
+regexp with `^` (usually followed by `\s*`), and end it with `$`.
+For example, `/^\s*\}$/` will reindent when a closing brace is
+added at the start of a line.
+*/
+function indentOnInput() {
+	return EditorState.transactionFilter.of((tr) => {
+		if (!tr.docChanged || !tr.isUserEvent("input.type") && !tr.isUserEvent("input.complete")) return tr;
+		let rules = tr.startState.languageDataAt("indentOnInput", tr.startState.selection.main.head);
+		if (!rules.length) return tr;
+		let doc = tr.newDoc, { head } = tr.newSelection.main, line = doc.lineAt(head);
+		if (head > line.from + DontIndentBeyond) return tr;
+		let lineStart = doc.sliceString(line.from, head);
+		if (!rules.some((r) => r.test(lineStart))) return tr;
+		let { state } = tr, last = -1, changes = [];
+		for (let { head } of state.selection.ranges) {
+			let line = state.doc.lineAt(head);
+			if (line.from == last) continue;
+			last = line.from;
+			let indent = getIndentation(state, line.from);
+			if (indent == null) continue;
+			let cur = /^\s*/.exec(line.text)[0];
+			let norm = indentString(state, indent);
+			if (cur != norm) changes.push({
+				from: line.from,
+				to: line.from + cur.length,
+				insert: norm
+			});
+		}
+		return changes.length ? [tr, {
+			changes,
+			sequential: true
+		}] : tr;
+	});
+}
+/**
+A facet that registers a code folding service. When called with
+the extent of a line, such a function should return a foldable
+range that starts on that line (but continues beyond it), if one
+can be found.
+*/
+const foldService = /*@__PURE__*/ Facet.define();
+/**
+This node prop is used to associate folding information with
+syntax node types. Given a syntax node, it should check whether
+that tree is foldable and return the range that can be collapsed
+when it is.
+*/
+const foldNodeProp = /*@__PURE__*/ new NodeProp();
+/**
+[Fold](https://codemirror.net/6/docs/ref/#language.foldNodeProp) function that folds everything but
+the first and the last child of a syntax node. Useful for nodes
+that start and end with delimiters.
+*/
+function foldInside(node) {
+	let first = node.firstChild, last = node.lastChild;
+	return first && first.to < last.from ? {
+		from: first.to,
+		to: last.type.isError ? node.to : last.from
+	} : null;
+}
+function syntaxFolding(state, start, end) {
+	let tree = syntaxTree(state);
+	if (tree.length < end) return null;
+	let stack = tree.resolveStack(end, 1);
+	let found = null;
+	for (let iter = stack; iter; iter = iter.next) {
+		let cur = iter.node;
+		if (cur.to <= end || cur.from > end) continue;
+		if (found && cur.from < start) break;
+		let prop = cur.type.prop(foldNodeProp);
+		if (prop && (cur.to < tree.length - 50 || tree.length == state.doc.length || !isUnfinished(cur))) {
+			let value = prop(cur, state);
+			if (value && value.from <= end && value.from >= start && value.to > end) found = value;
+		}
+	}
+	return found;
+}
+function isUnfinished(node) {
+	let ch = node.lastChild;
+	return ch && ch.to == node.to && ch.type.isError;
+}
+/**
+Check whether the given line is foldable. First asks any fold
+services registered through
+[`foldService`](https://codemirror.net/6/docs/ref/#language.foldService), and if none of them return
+a result, tries to query the [fold node
+prop](https://codemirror.net/6/docs/ref/#language.foldNodeProp) of syntax nodes that cover the end
+of the line.
+*/
+function foldable(state, lineStart, lineEnd) {
+	for (let service of state.facet(foldService)) {
+		let result = service(state, lineStart, lineEnd);
+		if (result) return result;
+	}
+	return syntaxFolding(state, lineStart, lineEnd);
+}
+function mapRange(range, mapping) {
+	let from = mapping.mapPos(range.from, 1), to = mapping.mapPos(range.to, -1);
+	return from >= to ? void 0 : {
+		from,
+		to
+	};
+}
+/**
+State effect that can be attached to a transaction to fold the
+given range. (You probably only need this in exceptional
+circumstances—usually you'll just want to let
+[`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode) and the [fold
+gutter](https://codemirror.net/6/docs/ref/#language.foldGutter) create the transactions.)
+*/
+const foldEffect = /*@__PURE__*/ StateEffect.define({ map: mapRange });
+/**
+State effect that unfolds the given range (if it was folded).
+*/
+const unfoldEffect = /*@__PURE__*/ StateEffect.define({ map: mapRange });
+function selectedLines(view) {
+	let lines = [];
+	for (let { head } of view.state.selection.ranges) {
+		if (lines.some((l) => l.from <= head && l.to >= head)) continue;
+		lines.push(view.lineBlockAt(head));
+	}
+	return lines;
+}
+/**
+The state field that stores the folded ranges (as a [decoration
+set](https://codemirror.net/6/docs/ref/#view.DecorationSet)). Can be passed to
+[`EditorState.toJSON`](https://codemirror.net/6/docs/ref/#state.EditorState.toJSON) and
+[`fromJSON`](https://codemirror.net/6/docs/ref/#state.EditorState^fromJSON) to serialize the fold
+state.
+*/
+const foldState = /*@__PURE__*/ StateField.define({
+	create() {
+		return Decoration.none;
+	},
+	update(folded, tr) {
+		if (tr.isUserEvent("delete")) tr.changes.iterChangedRanges((fromA, toA) => folded = clearTouchedFolds(folded, fromA, toA));
+		folded = folded.map(tr.changes);
+		let rangesToFold = [];
+		for (let e of tr.effects) if (e.is(foldEffect) && !foldExists(folded, e.value.from, e.value.to)) rangesToFold.push(e.value);
+		else if (e.is(unfoldEffect)) folded = folded.update({
+			filter: (from, to) => e.value.from != from || e.value.to != to,
+			filterFrom: e.value.from,
+			filterTo: e.value.to
+		});
+		if (rangesToFold.length) {
+			let { preparePlaceholder } = tr.state.facet(foldConfig);
+			let decorations = rangesToFold.map((value) => {
+				return (!preparePlaceholder ? foldWidget : Decoration.replace({ widget: new PreparedFoldWidget(preparePlaceholder(tr.state, value)) })).range(value.from, value.to);
+			});
+			folded = folded.update({ add: decorations });
+		}
+		if (tr.selection) folded = clearTouchedFolds(folded, tr.selection.main.head);
+		return folded;
+	},
+	provide: (f) => EditorView.decorations.from(f),
+	toJSON(folded, state) {
+		let ranges = [];
+		folded.between(0, state.doc.length, (from, to) => {
+			ranges.push(from, to);
+		});
+		return ranges;
+	},
+	fromJSON(value) {
+		if (!Array.isArray(value) || value.length % 2) throw new RangeError("Invalid JSON for fold state");
+		let ranges = [];
+		for (let i = 0; i < value.length;) {
+			let from = value[i++], to = value[i++];
+			if (typeof from != "number" || typeof to != "number") throw new RangeError("Invalid JSON for fold state");
+			ranges.push(foldWidget.range(from, to));
+		}
+		return Decoration.set(ranges, true);
+	}
+});
+function clearTouchedFolds(folded, from, to = from) {
+	let touched = false;
+	folded.between(from, to, (a, b) => {
+		if (a < to && b > from) touched = true;
+	});
+	return !touched ? folded : folded.update({
+		filterFrom: from,
+		filterTo: to,
+		filter: (a, b) => a >= to || b <= from
+	});
+}
+function findFold(state, from, to) {
+	var _a;
+	let found = null;
+	(_a = state.field(foldState, false)) === null || _a === void 0 || _a.between(from, to, (from, to) => {
+		if (!found || found.from > from) found = {
+			from,
+			to
+		};
+	});
+	return found;
+}
+function foldExists(folded, from, to) {
+	let found = false;
+	folded.between(from, from, (a, b) => {
+		if (a == from && b == to) found = true;
+	});
+	return found;
+}
+function maybeEnable(state, other) {
+	return state.field(foldState, false) ? other : other.concat(StateEffect.appendConfig.of(codeFolding()));
+}
+/**
+Fold the lines that are selected, if possible.
+*/
+const foldCode = (view) => {
+	for (let line of selectedLines(view)) {
+		let range = foldable(view.state, line.from, line.to);
+		if (range) {
+			view.dispatch({ effects: maybeEnable(view.state, [foldEffect.of(range), announceFold(view, range)]) });
+			return true;
+		}
+	}
+	return false;
+};
+/**
+Unfold folded ranges on selected lines.
+*/
+const unfoldCode = (view) => {
+	if (!view.state.field(foldState, false)) return false;
+	let effects = [];
+	for (let line of selectedLines(view)) {
+		let folded = findFold(view.state, line.from, line.to);
+		if (folded) effects.push(unfoldEffect.of(folded), announceFold(view, folded, false));
+	}
+	if (effects.length) view.dispatch({ effects });
+	return effects.length > 0;
+};
+function announceFold(view, range, fold = true) {
+	let lineFrom = view.state.doc.lineAt(range.from).number, lineTo = view.state.doc.lineAt(range.to).number;
+	return EditorView.announce.of(`${view.state.phrase(fold ? "Folded lines" : "Unfolded lines")} ${lineFrom} ${view.state.phrase("to")} ${lineTo}.`);
+}
+/**
+Fold all top-level foldable ranges. Note that, in most cases,
+folding information will depend on the [syntax
+tree](https://codemirror.net/6/docs/ref/#language.syntaxTree), and folding everything may not work
+reliably when the document hasn't been fully parsed (either
+because the editor state was only just initialized, or because the
+document is so big that the parser decided not to parse it
+entirely).
+*/
+const foldAll = (view) => {
+	let { state } = view, effects = [];
+	for (let pos = 0; pos < state.doc.length;) {
+		let line = view.lineBlockAt(pos), range = foldable(state, line.from, line.to);
+		if (range) effects.push(foldEffect.of(range));
+		pos = (range ? view.lineBlockAt(range.to) : line).to + 1;
+	}
+	if (effects.length) view.dispatch({ effects: maybeEnable(view.state, effects) });
+	return !!effects.length;
+};
+/**
+Unfold all folded code.
+*/
+const unfoldAll = (view) => {
+	let field = view.state.field(foldState, false);
+	if (!field || !field.size) return false;
+	let effects = [];
+	field.between(0, view.state.doc.length, (from, to) => {
+		effects.push(unfoldEffect.of({
+			from,
+			to
+		}));
+	});
+	view.dispatch({ effects });
+	return true;
+};
+/**
+Default fold-related key bindings.
+
+- Ctrl-Shift-[ (Cmd-Alt-[ on macOS): [`foldCode`](https://codemirror.net/6/docs/ref/#language.foldCode).
+- Ctrl-Shift-] (Cmd-Alt-] on macOS): [`unfoldCode`](https://codemirror.net/6/docs/ref/#language.unfoldCode).
+- Ctrl-Alt-[: [`foldAll`](https://codemirror.net/6/docs/ref/#language.foldAll).
+- Ctrl-Alt-]: [`unfoldAll`](https://codemirror.net/6/docs/ref/#language.unfoldAll).
+*/
+const foldKeymap = [
+	{
+		key: "Ctrl-Shift-[",
+		mac: "Cmd-Alt-[",
+		run: foldCode
+	},
+	{
+		key: "Ctrl-Shift-]",
+		mac: "Cmd-Alt-]",
+		run: unfoldCode
+	},
+	{
+		key: "Ctrl-Alt-[",
+		run: foldAll
+	},
+	{
+		key: "Ctrl-Alt-]",
+		run: unfoldAll
+	}
+];
+const defaultConfig = {
+	placeholderDOM: null,
+	preparePlaceholder: null,
+	placeholderText: "…"
+};
+const foldConfig = /*@__PURE__*/ Facet.define({ combine(values) {
+	return combineConfig(values, defaultConfig);
+} });
+/**
+Create an extension that configures code folding.
+*/
+function codeFolding(config) {
+	let result = [foldState, baseTheme$1];
+	if (config) result.push(foldConfig.of(config));
+	return result;
+}
+function widgetToDOM(view, prepared) {
+	let { state } = view, conf = state.facet(foldConfig);
+	let onclick = (event) => {
+		let line = view.lineBlockAt(view.posAtDOM(event.target));
+		let folded = findFold(view.state, line.from, line.to);
+		if (folded) view.dispatch({ effects: unfoldEffect.of(folded) });
+		event.preventDefault();
+	};
+	if (conf.placeholderDOM) return conf.placeholderDOM(view, onclick, prepared);
+	let element = document.createElement("span");
+	element.textContent = conf.placeholderText;
+	element.setAttribute("aria-label", state.phrase("folded code"));
+	element.title = state.phrase("unfold");
+	element.className = "cm-foldPlaceholder";
+	element.onclick = onclick;
+	return element;
+}
+const foldWidget = /*@__PURE__*/ Decoration.replace({ widget: /*@__PURE__*/ new class extends WidgetType {
+	toDOM(view) {
+		return widgetToDOM(view, null);
+	}
+}() });
+var PreparedFoldWidget = class extends WidgetType {
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	eq(other) {
+		return this.value == other.value;
+	}
+	toDOM(view) {
+		return widgetToDOM(view, this.value);
+	}
+};
+const foldGutterDefaults = {
+	openText: "⌄",
+	closedText: "›",
+	markerDOM: null,
+	domEventHandlers: {},
+	foldingChanged: () => false
+};
+var FoldMarker = class extends GutterMarker {
+	constructor(config, open) {
+		super();
+		this.config = config;
+		this.open = open;
+	}
+	eq(other) {
+		return this.config == other.config && this.open == other.open;
+	}
+	toDOM(view) {
+		if (this.config.markerDOM) return this.config.markerDOM(this.open);
+		let span = document.createElement("span");
+		span.textContent = this.open ? this.config.openText : this.config.closedText;
+		span.title = view.state.phrase(this.open ? "Fold line" : "Unfold line");
+		return span;
+	}
+};
+/**
+Create an extension that registers a fold gutter, which shows a
+fold status indicator before foldable lines (which can be clicked
+to fold or unfold the line).
+*/
+function foldGutter(config = {}) {
+	let fullConfig = {
+		...foldGutterDefaults,
+		...config
+	};
+	let canFold = new FoldMarker(fullConfig, true), canUnfold = new FoldMarker(fullConfig, false);
+	let markers = ViewPlugin.fromClass(class {
+		constructor(view) {
+			this.from = view.viewport.from;
+			this.markers = this.buildMarkers(view);
+		}
+		update(update) {
+			if (update.docChanged || update.viewportChanged || update.startState.facet(language) != update.state.facet(language) || update.startState.field(foldState, false) != update.state.field(foldState, false) || syntaxTree(update.startState) != syntaxTree(update.state) || fullConfig.foldingChanged(update)) this.markers = this.buildMarkers(update.view);
+		}
+		buildMarkers(view) {
+			let builder = new RangeSetBuilder();
+			for (let line of view.viewportLineBlocks) {
+				let mark = findFold(view.state, line.from, line.to) ? canUnfold : foldable(view.state, line.from, line.to) ? canFold : null;
+				if (mark) builder.add(line.from, line.from, mark);
+			}
+			return builder.finish();
+		}
+	});
+	let { domEventHandlers } = fullConfig;
+	return [
+		markers,
+		gutter({
+			class: "cm-foldGutter",
+			markers(view) {
+				var _a;
+				return ((_a = view.plugin(markers)) === null || _a === void 0 ? void 0 : _a.markers) || RangeSet.empty;
+			},
+			initialSpacer() {
+				return new FoldMarker(fullConfig, false);
+			},
+			domEventHandlers: {
+				...domEventHandlers,
+				click: (view, line, event) => {
+					if (domEventHandlers.click && domEventHandlers.click(view, line, event)) return true;
+					let folded = findFold(view.state, line.from, line.to);
+					if (folded) {
+						view.dispatch({ effects: unfoldEffect.of(folded) });
+						return true;
+					}
+					let range = foldable(view.state, line.from, line.to);
+					if (range) {
+						view.dispatch({ effects: foldEffect.of(range) });
+						return true;
+					}
+					return false;
+				}
+			}
+		}),
+		codeFolding()
+	];
+}
+const baseTheme$1 = /*@__PURE__*/ EditorView.baseTheme({
+	".cm-foldPlaceholder": {
+		backgroundColor: "#eee",
+		border: "1px solid #ddd",
+		color: "#888",
+		borderRadius: ".2em",
+		margin: "0 1px",
+		padding: "0 1px",
+		cursor: "pointer"
+	},
+	".cm-foldGutter span": {
+		padding: "0 1px",
+		cursor: "pointer"
+	}
+});
+/**
+A highlight style associates CSS styles with highlighting
+[tags](https://lezer.codemirror.net/docs/ref#highlight.Tag).
+*/
+var HighlightStyle = class HighlightStyle {
+	constructor(specs, options) {
+		this.specs = specs;
+		let modSpec;
+		function def(spec) {
+			let cls = StyleModule.newName();
+			(modSpec || (modSpec = Object.create(null)))["." + cls] = spec;
+			return cls;
+		}
+		const all = typeof options.all == "string" ? options.all : options.all ? def(options.all) : void 0;
+		const scopeOpt = options.scope;
+		this.scope = scopeOpt instanceof Language ? (type) => type.prop(languageDataProp) == scopeOpt.data : scopeOpt ? (type) => type == scopeOpt : void 0;
+		this.style = tagHighlighter(specs.map((style) => ({
+			tag: style.tag,
+			class: style.class || def(Object.assign({}, style, { tag: null }))
+		})), { all }).style;
+		this.module = modSpec ? new StyleModule(modSpec) : null;
+		this.themeType = options.themeType;
+	}
+	/**
+	Create a highlighter style that associates the given styles to
+	the given tags. The specs must be objects that hold a style tag
+	or array of tags in their `tag` property, and either a single
+	`class` property providing a static CSS class (for highlighter
+	that rely on external styling), or a
+	[`style-mod`](https://code.haverbeke.berlin/marijn/style-mod#documentation)-style
+	set of CSS properties (which define the styling for those tags).
+	
+	The CSS rules created for a highlighter will be emitted in the
+	order of the spec's properties. That means that for elements that
+	have multiple tags associated with them, styles defined further
+	down in the list will have a higher CSS precedence than styles
+	defined earlier.
+	*/
+	static define(specs, options) {
+		return new HighlightStyle(specs, options || {});
+	}
+};
+const highlighterFacet = /*@__PURE__*/ Facet.define();
+const fallbackHighlighter = /*@__PURE__*/ Facet.define({ combine(values) {
+	return values.length ? [values[0]] : null;
+} });
+function getHighlighters(state) {
+	let main = state.facet(highlighterFacet);
+	return main.length ? main : state.facet(fallbackHighlighter);
+}
+/**
+Wrap a highlighter in an editor extension that uses it to apply
+syntax highlighting to the editor content.
+
+When multiple (non-fallback) styles are provided, the styling
+applied is the union of the classes they emit.
+*/
+function syntaxHighlighting(highlighter, options) {
+	let ext = [treeHighlighter], themeType;
+	if (highlighter instanceof HighlightStyle) {
+		if (highlighter.module) ext.push(EditorView.styleModule.of(highlighter.module));
+		themeType = highlighter.themeType;
+	}
+	if (options === null || options === void 0 ? void 0 : options.fallback) ext.push(fallbackHighlighter.of(highlighter));
+	else if (themeType) ext.push(highlighterFacet.computeN([EditorView.darkTheme], (state) => {
+		return state.facet(EditorView.darkTheme) == (themeType == "dark") ? [highlighter] : [];
+	}));
+	else ext.push(highlighterFacet.of(highlighter));
+	return ext;
+}
+var TreeHighlighter = class {
+	constructor(view) {
+		this.markCache = Object.create(null);
+		this.tree = syntaxTree(view.state);
+		this.decorations = this.buildDeco(view, getHighlighters(view.state));
+		this.decoratedTo = view.viewport.to;
+	}
+	update(update) {
+		let tree = syntaxTree(update.state), highlighters = getHighlighters(update.state);
+		let styleChange = highlighters != getHighlighters(update.startState);
+		let { viewport } = update.view, decoratedToMapped = update.changes.mapPos(this.decoratedTo, 1);
+		if (tree.length < viewport.to && !styleChange && tree.type == this.tree.type && decoratedToMapped >= viewport.to) {
+			this.decorations = this.decorations.map(update.changes);
+			this.decoratedTo = decoratedToMapped;
+		} else if (tree != this.tree || update.viewportChanged || styleChange) {
+			this.tree = tree;
+			this.decorations = this.buildDeco(update.view, highlighters);
+			this.decoratedTo = viewport.to;
+		}
+	}
+	buildDeco(view, highlighters) {
+		if (!highlighters || !this.tree.length) return Decoration.none;
+		let builder = new RangeSetBuilder();
+		for (let { from, to } of view.visibleRanges) highlightTree(this.tree, highlighters, (from, to, style) => {
+			builder.add(from, to, this.markCache[style] || (this.markCache[style] = Decoration.mark({ class: style })));
+		}, from, to);
+		return builder.finish();
+	}
+};
+const treeHighlighter = /*@__PURE__*/ Prec.high(/*@__PURE__*/ ViewPlugin.fromClass(TreeHighlighter, { decorations: (v) => v.decorations }));
+/**
+A default highlight style (works well with light themes).
+*/
+const defaultHighlightStyle = /*@__PURE__*/ HighlightStyle.define([
+	{
+		tag: tags.meta,
+		color: "#404740"
+	},
+	{
+		tag: tags.link,
+		textDecoration: "underline"
+	},
+	{
+		tag: tags.heading,
+		textDecoration: "underline",
+		fontWeight: "bold"
+	},
+	{
+		tag: tags.emphasis,
+		fontStyle: "italic"
+	},
+	{
+		tag: tags.strong,
+		fontWeight: "bold"
+	},
+	{
+		tag: tags.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: tags.keyword,
+		color: "#708"
+	},
+	{
+		tag: [
+			tags.atom,
+			tags.bool,
+			tags.url,
+			tags.contentSeparator,
+			tags.labelName
+		],
+		color: "#219"
+	},
+	{
+		tag: [tags.literal, tags.inserted],
+		color: "#164"
+	},
+	{
+		tag: [tags.string, tags.deleted],
+		color: "#a11"
+	},
+	{
+		tag: [
+			tags.regexp,
+			tags.escape,
+			/*@__PURE__*/ tags.special(tags.string)
+		],
+		color: "#e40"
+	},
+	{
+		tag: /*@__PURE__*/ tags.definition(tags.variableName),
+		color: "#00f"
+	},
+	{
+		tag: /*@__PURE__*/ tags.local(tags.variableName),
+		color: "#30a"
+	},
+	{
+		tag: [tags.typeName, tags.namespace],
+		color: "#085"
+	},
+	{
+		tag: tags.className,
+		color: "#167"
+	},
+	{
+		tag: [/*@__PURE__*/ tags.special(tags.variableName), tags.macroName],
+		color: "#256"
+	},
+	{
+		tag: /*@__PURE__*/ tags.definition(tags.propertyName),
+		color: "#00c"
+	},
+	{
+		tag: tags.comment,
+		color: "#940"
+	},
+	{
+		tag: tags.invalid,
+		color: "#f00"
+	}
+]);
+const baseTheme = /*@__PURE__*/ EditorView.baseTheme({
+	"&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+	"&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+});
+const DefaultScanDist = 1e4, DefaultBrackets = "()[]{}";
+const bracketMatchingConfig = /*@__PURE__*/ Facet.define({ combine(configs) {
+	return combineConfig(configs, {
+		afterCursor: true,
+		brackets: DefaultBrackets,
+		maxScanDistance: DefaultScanDist,
+		renderMatch: defaultRenderMatch
+	});
+} });
+const matchingMark = /*@__PURE__*/ Decoration.mark({ class: "cm-matchingBracket" }), nonmatchingMark = /*@__PURE__*/ Decoration.mark({ class: "cm-nonmatchingBracket" });
+function defaultRenderMatch(match) {
+	let decorations = [];
+	let mark = match.matched ? matchingMark : nonmatchingMark;
+	decorations.push(mark.range(match.start.from, match.start.to));
+	if (match.end) decorations.push(mark.range(match.end.from, match.end.to));
+	return decorations;
+}
+function bracketDeco(state) {
+	let decorations = [];
+	let config = state.facet(bracketMatchingConfig);
+	for (let range of state.selection.ranges) {
+		if (!range.empty) continue;
+		let match = matchBrackets(state, range.head, -1, config) || range.head > 0 && matchBrackets(state, range.head - 1, 1, config) || config.afterCursor && (matchBrackets(state, range.head, 1, config) || range.head < state.doc.length && matchBrackets(state, range.head + 1, -1, config));
+		if (match) decorations = decorations.concat(config.renderMatch(match, state));
+	}
+	return Decoration.set(decorations, true);
+}
+const bracketMatchingUnique = [/* @__PURE__ */ ViewPlugin.fromClass(class {
+	constructor(view) {
+		this.paused = false;
+		this.decorations = bracketDeco(view.state);
+	}
+	update(update) {
+		if (update.docChanged || update.selectionSet || this.paused) if (update.view.composing) {
+			this.decorations = this.decorations.map(update.changes);
+			this.paused = true;
+		} else {
+			this.decorations = bracketDeco(update.state);
+			this.paused = false;
+		}
+	}
+}, { decorations: (v) => v.decorations }), baseTheme];
+/**
+Create an extension that enables bracket matching. Whenever the
+cursor is next to a bracket, that bracket and the one it matches
+are highlighted. Or, when no matching bracket is found, another
+highlighting style is used to indicate this.
+*/
+function bracketMatching(config = {}) {
+	return [bracketMatchingConfig.of(config), bracketMatchingUnique];
+}
+/**
+When larger syntax nodes, such as HTML tags, are marked as
+opening/closing, it can be a bit messy to treat the whole node as
+a matchable bracket. This node prop allows you to define, for such
+a node, a ‘handle’—the part of the node that is highlighted, and
+that the cursor must be on to activate highlighting in the first
+place.
+*/
+const bracketMatchingHandle = /*@__PURE__*/ new NodeProp();
+function matchingNodes(node, dir, brackets) {
+	let byProp = node.prop(dir < 0 ? NodeProp.openedBy : NodeProp.closedBy);
+	if (byProp) return byProp;
+	if (node.name.length == 1) {
+		let index = brackets.indexOf(node.name);
+		if (index > -1 && index % 2 == (dir < 0 ? 1 : 0)) return [brackets[index + dir]];
+	}
+	return null;
+}
+function findHandle(node) {
+	let hasHandle = node.type.prop(bracketMatchingHandle);
+	return hasHandle ? hasHandle(node.node) : node;
+}
+/**
+Find the matching bracket for the token at `pos`, scanning
+direction `dir`. Only the `brackets` and `maxScanDistance`
+properties are used from `config`, if given. Returns null if no
+bracket was found at `pos`, or a match result otherwise.
+*/
+function matchBrackets(state, pos, dir, config = {}) {
+	let maxScanDistance = config.maxScanDistance || DefaultScanDist, brackets = config.brackets || DefaultBrackets;
+	let tree = syntaxTree(state), node = tree.resolveInner(pos, dir);
+	for (let cur = node; cur; cur = cur.parent) {
+		let matches = matchingNodes(cur.type, dir, brackets);
+		if (matches && cur.from < cur.to) {
+			let handle = findHandle(cur);
+			if (handle && (dir > 0 ? pos >= handle.from && pos < handle.to : pos > handle.from && pos <= handle.to)) return matchMarkedBrackets(state, pos, dir, cur, handle, matches, brackets);
+		}
+	}
+	return matchPlainBrackets(state, pos, dir, tree, node.type, maxScanDistance, brackets);
+}
+function matchMarkedBrackets(_state, _pos, dir, token, handle, matching, brackets) {
+	let parent = token.parent, firstToken = {
+		from: handle.from,
+		to: handle.to
+	};
+	let depth = 0, cursor = parent === null || parent === void 0 ? void 0 : parent.cursor();
+	if (cursor && (dir < 0 ? cursor.childBefore(token.from) : cursor.childAfter(token.to))) do
+		if (dir < 0 ? cursor.to <= token.from : cursor.from >= token.to) {
+			if (depth == 0 && matching.indexOf(cursor.type.name) > -1 && cursor.from < cursor.to) {
+				let endHandle = findHandle(cursor);
+				return {
+					start: firstToken,
+					end: endHandle ? {
+						from: endHandle.from,
+						to: endHandle.to
+					} : void 0,
+					matched: true
+				};
+			} else if (matchingNodes(cursor.type, dir, brackets)) depth++;
+			else if (matchingNodes(cursor.type, -dir, brackets)) {
+				if (depth == 0) {
+					let endHandle = findHandle(cursor);
+					return {
+						start: firstToken,
+						end: endHandle && endHandle.from < endHandle.to ? {
+							from: endHandle.from,
+							to: endHandle.to
+						} : void 0,
+						matched: false
+					};
+				}
+				depth--;
+			}
+		}
+	while (dir < 0 ? cursor.prevSibling() : cursor.nextSibling());
+	return {
+		start: firstToken,
+		matched: false
+	};
+}
+function matchPlainBrackets(state, pos, dir, tree, tokenType, maxScanDistance, brackets) {
+	if (dir < 0 ? !pos : pos == state.doc.length) return null;
+	let startCh = dir < 0 ? state.sliceDoc(pos - 1, pos) : state.sliceDoc(pos, pos + 1);
+	let bracket = brackets.indexOf(startCh);
+	if (bracket < 0 || bracket % 2 == 0 != dir > 0) return null;
+	let startToken = {
+		from: dir < 0 ? pos - 1 : pos,
+		to: dir > 0 ? pos + 1 : pos
+	};
+	let iter = state.doc.iterRange(pos, dir > 0 ? state.doc.length : 0), depth = 0;
+	for (let distance = 0; !iter.next().done && distance <= maxScanDistance;) {
+		let text = iter.value;
+		if (dir < 0) distance += text.length;
+		let basePos = pos + distance * dir;
+		for (let pos = dir > 0 ? 0 : text.length - 1, end = dir > 0 ? text.length : -1; pos != end; pos += dir) {
+			let found = brackets.indexOf(text[pos]);
+			if (found < 0 || tree.resolveInner(basePos + pos, 1).type != tokenType) continue;
+			if (found % 2 == 0 == dir > 0) depth++;
+			else if (depth == 1) return {
+				start: startToken,
+				end: {
+					from: basePos + pos,
+					to: basePos + pos + 1
+				},
+				matched: found >> 1 == bracket >> 1
+			};
+			else depth--;
+		}
+		if (dir > 0) distance += text.length;
+	}
+	return iter.done ? {
+		start: startToken,
+		matched: false
+	} : null;
+}
+const noTokens = /*@__PURE__*/ Object.create(null);
+const typeArray = [NodeType.none];
+const warned = [];
+const byTag = /*@__PURE__*/ Object.create(null);
+const defaultTable = /*@__PURE__*/ Object.create(null);
+for (let [legacyName, name] of [
+	["variable", "variableName"],
+	["variable-2", "variableName.special"],
+	["string-2", "string.special"],
+	["def", "variableName.definition"],
+	["tag", "tagName"],
+	["attribute", "attributeName"],
+	["type", "typeName"],
+	["builtin", "variableName.standard"],
+	["qualifier", "modifier"],
+	["error", "invalid"],
+	["header", "heading"],
+	["property", "propertyName"]
+]) defaultTable[legacyName] = /*@__PURE__*/ createTokenType(noTokens, name);
+function warnForPart(part, msg) {
+	if (warned.indexOf(part) > -1) return;
+	warned.push(part);
+	console.warn(msg);
+}
+function createTokenType(extra, tagStr) {
+	let tags$1 = [];
+	for (let name of tagStr.split(" ")) {
+		let found = [];
+		for (let part of name.split(".")) {
+			let value = extra[part] || tags[part];
+			if (!value) warnForPart(part, `Unknown highlighting tag ${part}`);
+			else if (typeof value == "function") if (!found.length) warnForPart(part, `Modifier ${part} used at start of tag`);
+			else found = found.map(value);
+			else if (found.length) warnForPart(part, `Tag ${part} used as modifier`);
+			else found = Array.isArray(value) ? value : [value];
+		}
+		for (let tag of found) tags$1.push(tag);
+	}
+	if (!tags$1.length) return 0;
+	let name = tagStr.replace(/ /g, "_"), key = name + " " + tags$1.map((t) => t.id);
+	let known = byTag[key];
+	if (known) return known.id;
+	let type = byTag[key] = NodeType.define({
+		id: typeArray.length,
+		name,
+		props: [styleTags({ [name]: tags$1 })]
+	});
+	typeArray.push(type);
+	return type.id;
+}
+Direction.RTL, Direction.LTR;
+//#endregion
+export { HighlightStyle, IndentContext, LRLanguage, LanguageSupport, bracketMatching, continuedIndent, defaultHighlightStyle, defineLanguageFacet, delimitedIndent, flatIndent, foldGutter, foldInside, foldKeymap, foldNodeProp, getIndentUnit, getIndentation, indentNodeProp, indentOnInput, indentString, indentUnit, matchBrackets, sublanguageProp, syntaxHighlighting, syntaxTree };
+
+//# sourceMappingURL=index.js.map