@oomol-lab/open-flow 0.1.0-alpha.0

package/dist/browser/dist-CvcmLAMW.js

@@ -0,0 +1,1620 @@
+import { r as e } from "./rolldown-runtime-CEFd7nDs.js";
+import { a as t, c as n, d as r, h as i, i as a, l as o, m as s, o as c, p as l, r as u, u as d } from "./dist-zyY--HOV.js";
+import { b as ee, d as f, l as te, m as ne, o as p, p as m, s as h, u as re, y as ie } from "./dist-BLk5M0uK.js";
+import { O as ae, a as g, i as oe, m as se, n as _, o as ce, r as v, t as y, x as le } from "./dist-CIq6ue3I.js";
+//#region ../../node_modules/@codemirror/language/dist/index.js
+var ue = /* @__PURE__ */ e({
+	DocInput: () => _e,
+	HighlightStyle: () => Y,
+	IndentContext: () => P,
+	LRLanguage: () => fe,
+	Language: () => C,
+	LanguageDescription: () => Se,
+	LanguageSupport: () => xe,
+	ParseContext: () => E,
+	StreamLanguage: () => Nt,
+	StringStream: () => kt,
+	TreeIndentContext: () => Ae,
+	bidiIsolates: () => Qt,
+	bracketMatching: () => St,
+	bracketMatchingHandle: () => Ct,
+	codeFolding: () => q,
+	continuedIndent: () => Ie,
+	defaultHighlightStyle: () => ft,
+	defineLanguageFacet: () => x,
+	delimitedIndent: () => Ne,
+	ensureSyntaxTree: () => pe,
+	flatIndent: () => Fe,
+	foldAll: () => Je,
+	foldCode: () => Ke,
+	foldEffect: () => z,
+	foldGutter: () => it,
+	foldInside: () => ze,
+	foldKeymap: () => Qe,
+	foldNodeProp: () => L,
+	foldService: () => I,
+	foldState: () => H,
+	foldable: () => R,
+	foldedRanges: () => We,
+	forceParsing: () => he,
+	getIndentUnit: () => j,
+	getIndentation: () => N,
+	highlightingFor: () => lt,
+	indentNodeProp: () => F,
+	indentOnInput: () => Re,
+	indentRange: () => we,
+	indentService: () => Ce,
+	indentString: () => M,
+	indentUnit: () => A,
+	language: () => k,
+	languageDataProp: () => b,
+	matchBrackets: () => Z,
+	sublanguageProp: () => S,
+	syntaxHighlighting: () => ct,
+	syntaxParserRunning: () => ge,
+	syntaxTree: () => w,
+	syntaxTreeAvailable: () => me,
+	toggleFold: () => Ze,
+	unfoldAll: () => Ye,
+	unfoldCode: () => qe,
+	unfoldEffect: () => B
+}), b = /*@__PURE__*/ new o();
+function x(e) {
+	return h.define({ combine: e ? (t) => t.concat(e) : void 0 });
+}
+var S = /*@__PURE__*/ new o(), C = class {
+	constructor(e, t, n = [], r = "") {
+		this.data = e, this.name = r, p.prototype.hasOwnProperty("tree") || Object.defineProperty(p.prototype, "tree", { get() {
+			return w(this);
+		} }), this.parser = t, this.extension = [k.of(this), p.languageData.of((e, t, n) => {
+			let r = de(e, t, n), i = r.type.prop(b);
+			if (!i) return [];
+			let a = e.facet(i), o = r.type.prop(S);
+			if (o) {
+				let i = r.resolve(t - r.from, n);
+				for (let t of o) if (t.test(i, e)) {
+					let n = e.facet(t.facet);
+					return t.type == "replace" ? n : n.concat(a);
+				}
+			}
+			return a;
+		})].concat(n);
+	}
+	isActiveAt(e, t, n = -1) {
+		return de(e, t, n).type.prop(b) == this.data;
+	}
+	findRegions(e) {
+		let t = e.facet(k);
+		if (t?.data == this.data) return [{
+			from: 0,
+			to: e.doc.length
+		}];
+		if (!t || !t.allowsNesting) return [];
+		let n = [], r = (e, t) => {
+			if (e.prop(b) == this.data) {
+				n.push({
+					from: t,
+					to: t + e.length
+				});
+				return;
+			}
+			let i = e.prop(o.mounted);
+			if (i) {
+				if (i.tree.prop(b) == this.data) {
+					if (i.overlay) for (let e of i.overlay) n.push({
+						from: e.from + t,
+						to: e.to + t
+					});
+					else n.push({
+						from: t,
+						to: t + e.length
+					});
+					return;
+				}
+				if (i.overlay) {
+					let e = n.length;
+					if (r(i.tree, i.overlay[0].from + t), n.length > e) return;
+				}
+			}
+			for (let n = 0; n < e.children.length; n++) {
+				let i = e.children[n];
+				i instanceof s && r(i, e.positions[n] + t);
+			}
+		};
+		return r(w(e), 0), n;
+	}
+	get allowsNesting() {
+		return !0;
+	}
+};
+C.setState = /*@__PURE__*/ m.define();
+function de(e, t, r) {
+	let i = e.facet(k), a = w(e).topNode;
+	if (!i || i.allowsNesting) for (let e = a; e; e = e.enter(t, r, n.ExcludeBuffers | n.EnterBracketed)) e.type.isTop && (a = e);
+	return a;
+}
+var fe = class e extends C {
+	constructor(e, t, n) {
+		super(e, t, [], n), this.parser = t;
+	}
+	static define(t) {
+		let n = x(t.languageData);
+		return new e(n, t.parser.configure({ props: [b.add((e) => e.isTop ? n : void 0)] }), t.name);
+	}
+	configure(t, n) {
+		return new e(this.data, this.parser.configure(t), n || this.name);
+	}
+	get allowsNesting() {
+		return this.parser.hasWrappers();
+	}
+};
+function w(e) {
+	let t = e.field(C.state, !1);
+	return t ? t.tree : s.empty;
+}
+function pe(e, t, n = 50) {
+	let r = e.field(C.state, !1)?.context;
+	if (!r) return null;
+	let i = r.viewport;
+	r.updateViewport({
+		from: 0,
+		to: t
+	});
+	let a = r.isDone(t) || r.work(n, t) ? r.tree : null;
+	return r.updateViewport(i), a;
+}
+function me(e, t = e.doc.length) {
+	return e.field(C.state, !1)?.context.isDone(t) || !1;
+}
+function he(e, t = e.viewport.to, n = 100) {
+	let r = pe(e.state, t, n);
+	return r != w(e.state) && e.dispatch({}), !!r;
+}
+function ge(e) {
+	return e.plugin(be)?.isWorking() || !1;
+}
+var _e = class {
+	constructor(e) {
+		this.doc = e, this.cursorPos = 0, this.string = "", this.cursor = e.iter();
+	}
+	get length() {
+		return this.doc.length;
+	}
+	syncTo(e) {
+		return this.string = this.cursor.next(e - this.cursorPos).value, this.cursorPos = e + this.string.length, this.cursorPos - this.string.length;
+	}
+	chunk(e) {
+		return this.syncTo(e), this.string;
+	}
+	get lineChunks() {
+		return !0;
+	}
+	read(e, t) {
+		let n = this.cursorPos - this.string.length;
+		return e < n || t >= this.cursorPos ? this.doc.sliceString(e, t) : this.string.slice(e - n, t - n);
+	}
+}, T = null, E = class e {
+	constructor(e, t, n = [], r, i, a, o, s) {
+		this.parser = e, this.state = t, this.fragments = n, this.tree = r, this.treeLen = i, this.viewport = a, this.skipped = o, this.scheduleOn = s, this.parse = null, this.tempSkipped = [];
+	}
+	static create(t, n, r) {
+		return new e(t, n, [], s.empty, 0, r, [], null);
+	}
+	startParse() {
+		return this.parser.startParse(new _e(this.state.doc), this.fragments);
+	}
+	work(e, t) {
+		return t != null && t >= this.state.doc.length && (t = void 0), this.tree != s.empty && this.isDone(t ?? this.state.doc.length) ? (this.takeTree(), !0) : this.withContext(() => {
+			if (typeof e == "number") {
+				let t = Date.now() + e;
+				e = () => Date.now() > t;
+			}
+			for (this.parse ||= this.startParse(), t != null && (this.parse.stoppedAt == null || this.parse.stoppedAt > t) && t < this.state.doc.length && this.parse.stopAt(t);;) {
+				let n = this.parse.advance();
+				if (n) {
+					if (this.fragments = this.withoutTempSkipped(i.addTree(n, this.fragments, this.parse.stoppedAt != null)), this.treeLen = this.parse.stoppedAt ?? this.state.doc.length, this.tree = n, this.parse = null, this.treeLen < (t ?? this.state.doc.length)) this.parse = this.startParse();
+					else return !0;
+				}
+				if (e()) return !1;
+			}
+		});
+	}
+	takeTree() {
+		let e, t;
+		this.parse && (e = this.parse.parsedPos) >= this.treeLen && ((this.parse.stoppedAt == null || this.parse.stoppedAt > e) && this.parse.stopAt(e), this.withContext(() => {
+			for (; !(t = this.parse.advance()););
+		}), this.treeLen = e, this.tree = t, this.fragments = this.withoutTempSkipped(i.addTree(this.tree, this.fragments, !0)), this.parse = null);
+	}
+	withContext(e) {
+		let t = T;
+		T = this;
+		try {
+			return e();
+		} finally {
+			T = t;
+		}
+	}
+	withoutTempSkipped(e) {
+		for (let t; t = this.tempSkipped.pop();) e = ve(e, t.from, t.to);
+		return e;
+	}
+	changes(t, n) {
+		let { fragments: r, tree: a, treeLen: o, viewport: c, skipped: l } = this;
+		if (this.takeTree(), !t.empty) {
+			let e = [];
+			if (t.iterChangedRanges((t, n, r, i) => e.push({
+				fromA: t,
+				toA: n,
+				fromB: r,
+				toB: i
+			})), r = i.applyChanges(r, e), a = s.empty, o = 0, c = {
+				from: t.mapPos(c.from, -1),
+				to: t.mapPos(c.to, 1)
+			}, this.skipped.length) {
+				l = [];
+				for (let e of this.skipped) {
+					let n = t.mapPos(e.from, 1), r = t.mapPos(e.to, -1);
+					n < r && l.push({
+						from: n,
+						to: r
+					});
+				}
+			}
+		}
+		return new e(this.parser, n, r, a, o, c, l, this.scheduleOn);
+	}
+	updateViewport(e) {
+		if (this.viewport.from == e.from && this.viewport.to == e.to) return !1;
+		this.viewport = e;
+		let t = this.skipped.length;
+		for (let t = 0; t < this.skipped.length; t++) {
+			let { from: n, to: r } = this.skipped[t];
+			n < e.to && r > e.from && (this.fragments = ve(this.fragments, n, r), this.skipped.splice(t--, 1));
+		}
+		return this.skipped.length >= t ? !1 : (this.reset(), !0);
+	}
+	reset() {
+		this.parse &&= (this.takeTree(), null);
+	}
+	skipUntilInView(e, t) {
+		this.skipped.push({
+			from: e,
+			to: t
+		});
+	}
+	static getSkippingParser(e) {
+		return new class extends l {
+			createParse(t, n, i) {
+				let a = i[0].from, o = i[i.length - 1].to;
+				return {
+					parsedPos: a,
+					advance() {
+						let t = T;
+						if (t) {
+							for (let e of i) t.tempSkipped.push(e);
+							e && (t.scheduleOn = t.scheduleOn ? Promise.all([t.scheduleOn, e]) : e);
+						}
+						return this.parsedPos = o, new s(r.none, [], [], o - a);
+					},
+					stoppedAt: null,
+					stopAt() {}
+				};
+			}
+		}();
+	}
+	isDone(e) {
+		e = Math.min(e, this.state.doc.length);
+		let t = this.fragments;
+		return this.treeLen >= e && t.length && t[0].from == 0 && t[0].to >= e;
+	}
+	static get() {
+		return T;
+	}
+};
+function ve(e, t, n) {
+	return i.applyChanges(e, [{
+		fromA: t,
+		toA: n,
+		fromB: t,
+		toB: n
+	}]);
+}
+var D = class e {
+	constructor(e) {
+		this.context = e, this.tree = e.tree;
+	}
+	apply(t) {
+		if (!t.docChanged && this.tree == this.context.tree) return this;
+		let n = this.context.changes(t.changes, t.state), r = this.context.treeLen == t.startState.doc.length ? void 0 : Math.max(t.changes.mapPos(this.context.treeLen), n.viewport.to);
+		return n.work(20, r) || n.takeTree(), new e(n);
+	}
+	static init(t) {
+		let n = Math.min(3e3, t.doc.length), r = E.create(t.facet(k).parser, t, {
+			from: 0,
+			to: n
+		});
+		return r.work(20, n) || r.takeTree(), new e(r);
+	}
+};
+C.state = /*@__PURE__*/ ne.define({
+	create: D.init,
+	update(e, t) {
+		for (let e of t.effects) if (e.is(C.setState)) return e.value;
+		return t.startState.facet(k) == t.state.facet(k) ? e.apply(t) : D.init(t.state);
+	}
+});
+var ye = (e) => {
+	let t = setTimeout(() => e(), 500);
+	return () => clearTimeout(t);
+};
+typeof requestIdleCallback < "u" && (ye = (e) => {
+	let t = -1, n = setTimeout(() => {
+		t = requestIdleCallback(e, { timeout: 400 });
+	}, 100);
+	return () => t < 0 ? clearTimeout(n) : cancelIdleCallback(t);
+});
+var O = typeof navigator < "u" && navigator.scheduling?.isInputPending ? () => navigator.scheduling.isInputPending() : null, be = /*@__PURE__*/ g.fromClass(class {
+	constructor(e) {
+		this.view = e, this.working = null, this.workScheduled = 0, this.chunkEnd = -1, this.chunkBudget = -1, this.work = this.work.bind(this), this.scheduleWork();
+	}
+	update(e) {
+		let t = this.view.state.field(C.state).context;
+		(t.updateViewport(e.view.viewport) || this.view.viewport.to > t.treeLen) && this.scheduleWork(), (e.docChanged || e.selectionSet) && (this.view.hasFocus && (this.chunkBudget += 50), this.scheduleWork()), this.checkAsyncSchedule(t);
+	}
+	scheduleWork() {
+		if (this.working) return;
+		let { state: e } = this.view, t = e.field(C.state);
+		(t.tree != t.context.tree || !t.context.isDone(e.doc.length)) && (this.working = ye(this.work));
+	}
+	work(e) {
+		this.working = null;
+		let t = Date.now();
+		if (this.chunkEnd < t && (this.chunkEnd < 0 || this.view.hasFocus) && (this.chunkEnd = t + 3e4, this.chunkBudget = 3e3), this.chunkBudget <= 0) return;
+		let { state: n, viewport: { to: r } } = this.view, i = n.field(C.state);
+		if (i.tree == i.context.tree && i.context.isDone(r + 1e5)) return;
+		let a = Date.now() + Math.min(this.chunkBudget, 100, e && !O ? Math.max(25, e.timeRemaining() - 5) : 1e9), o = i.context.treeLen < r && n.doc.length > r + 1e3, s = i.context.work(() => O && O() || Date.now() > a, r + (o ? 0 : 1e5));
+		this.chunkBudget -= Date.now() - t, (s || this.chunkBudget <= 0) && (i.context.takeTree(), this.view.dispatch({ effects: C.setState.of(new D(i.context)) })), this.chunkBudget > 0 && !(s && !o) && this.scheduleWork(), this.checkAsyncSchedule(i.context);
+	}
+	checkAsyncSchedule(e) {
+		e.scheduleOn &&= (this.workScheduled++, e.scheduleOn.then(() => this.scheduleWork()).catch((e) => le(this.view.state, e)).then(() => this.workScheduled--), null);
+	}
+	destroy() {
+		this.working && this.working();
+	}
+	isWorking() {
+		return !!(this.working || this.workScheduled > 0);
+	}
+}, { eventHandlers: { focus() {
+	this.scheduleWork();
+} } }), k = /*@__PURE__*/ h.define({
+	combine(e) {
+		return e.length ? e[0] : null;
+	},
+	enables: (e) => [
+		C.state,
+		be,
+		v.contentAttributes.compute([e], (t) => {
+			let n = t.facet(e);
+			return n && n.name ? { "data-language": n.name } : {};
+		})
+	]
+}), xe = class {
+	constructor(e, t = []) {
+		this.language = e, this.support = t, this.extension = [e, t];
+	}
+}, Se = class e {
+	constructor(e, t, n, r, i, a = void 0) {
+		this.name = e, this.alias = t, this.extensions = n, this.filename = r, this.loadFunc = i, this.support = a, this.loading = null;
+	}
+	load() {
+		return this.loading ||= this.loadFunc().then((e) => this.support = e, (e) => {
+			throw this.loading = null, e;
+		});
+	}
+	static of(t) {
+		let { load: n, support: r } = t;
+		if (!n) {
+			if (!r) throw RangeError("Must pass either 'load' or 'support' to LanguageDescription.of");
+			n = () => Promise.resolve(r);
+		}
+		return new e(t.name, (t.alias || []).concat(t.name).map((e) => e.toLowerCase()), t.extensions || [], t.filename, n, r);
+	}
+	static matchFilename(e, t) {
+		for (let n of e) if (n.filename && n.filename.test(t)) return n;
+		let n = /\.([^.]+)$/.exec(t);
+		if (n) {
+			for (let t of e) if (t.extensions.indexOf(n[1]) > -1) return t;
+		}
+		return null;
+	}
+	static matchLanguageName(e, t, n = !0) {
+		t = t.toLowerCase();
+		for (let n of e) if (n.alias.some((e) => e == t)) return n;
+		if (n) for (let n of e) for (let e of n.alias) {
+			let r = t.indexOf(e);
+			if (r > -1 && (e.length > 2 || !/\w/.test(t[r - 1]) && !/\w/.test(t[r + e.length]))) return n;
+		}
+		return null;
+	}
+}, Ce = /*@__PURE__*/ h.define(), A = /*@__PURE__*/ h.define({ combine: (e) => {
+	if (!e.length) return "  ";
+	let t = e[0];
+	if (!t || /\S/.test(t) || Array.from(t).some((e) => e != t[0])) throw Error("Invalid indent unit: " + JSON.stringify(e[0]));
+	return t;
+} });
+function j(e) {
+	let t = e.facet(A);
+	return t.charCodeAt(0) == 9 ? e.tabSize * t.length : t.length;
+}
+function M(e, t) {
+	let n = "", r = e.tabSize, i = e.facet(A)[0];
+	if (i == "	") {
+		for (; t >= r;) n += "	", t -= r;
+		i = " ";
+	}
+	for (let e = 0; e < t; e++) n += i;
+	return n;
+}
+function N(e, t) {
+	e instanceof p && (e = new P(e));
+	for (let n of e.state.facet(Ce)) {
+		let r = n(e, t);
+		if (r !== void 0) return r;
+	}
+	let n = w(e.state);
+	return n.length >= t ? Te(e, n, t) : null;
+}
+function we(e, t, n) {
+	let r = Object.create(null), i = new P(e, { overrideIndentation: (e) => r[e] ?? -1 }), a = [];
+	for (let o = t; o <= n;) {
+		let t = e.doc.lineAt(o);
+		o = t.to + 1;
+		let n = N(i, t.from);
+		if (n == null) continue;
+		/\S/.test(t.text) || (n = 0);
+		let s = /^\s*/.exec(t.text)[0], c = M(e, n);
+		s != c && (r[t.from] = n, a.push({
+			from: t.from,
+			to: t.from + s.length,
+			insert: c
+		}));
+	}
+	return e.changes(a);
+}
+var P = class {
+	constructor(e, t = {}) {
+		this.state = e, this.options = t, this.unit = j(e);
+	}
+	lineAt(e, t = 1) {
+		let n = this.state.doc.lineAt(e), { simulateBreak: r, simulateDoubleBreak: i } = this.options;
+		return r != null && r >= n.from && r <= n.to ? i && r == e ? {
+			text: "",
+			from: e
+		} : (t < 0 ? r < e : r <= e) ? {
+			text: n.text.slice(r - n.from),
+			from: r
+		} : {
+			text: n.text.slice(0, r - n.from),
+			from: n.from
+		} : n;
+	}
+	textAfterPos(e, t = 1) {
+		if (this.options.simulateDoubleBreak && e == this.options.simulateBreak) return "";
+		let { text: n, from: r } = this.lineAt(e, t);
+		return n.slice(e - r, Math.min(n.length, e + 100 - r));
+	}
+	column(e, t = 1) {
+		let { text: n, from: r } = this.lineAt(e, t), i = this.countColumn(n, e - r), a = this.options.overrideIndentation ? this.options.overrideIndentation(r) : -1;
+		return a > -1 && (i += a - this.countColumn(n, n.search(/\S|$/))), i;
+	}
+	countColumn(e, t = e.length) {
+		return ee(e, this.state.tabSize, t);
+	}
+	lineIndent(e, t = 1) {
+		let { text: n, from: r } = this.lineAt(e, t), i = this.options.overrideIndentation;
+		if (i) {
+			let e = i(r);
+			if (e > -1) return e;
+		}
+		return this.countColumn(n, n.search(/\S|$/));
+	}
+	get simulatedBreak() {
+		return this.options.simulateBreak || null;
+	}
+}, F = /*@__PURE__*/ new o();
+function Te(e, t, n) {
+	let r = t.resolveStack(n), i = t.resolveInner(n, -1).resolve(n, 0).enterUnfinishedNodesBefore(n);
+	if (i != r.node) {
+		let e = [];
+		for (let t = i; t && !(t.from < r.node.from || t.to > r.node.to || t.from == r.node.from && t.type == r.node.type); t = t.parent) e.push(t);
+		for (let t = e.length - 1; t >= 0; t--) r = {
+			node: e[t],
+			next: r
+		};
+	}
+	return Ee(r, e, n);
+}
+function Ee(e, t, n) {
+	for (let r = e; r; r = r.next) {
+		let e = Oe(r.node);
+		if (e) return e(Ae.create(t, n, r));
+	}
+	return 0;
+}
+function De(e) {
+	return e.pos == e.options.simulateBreak && e.options.simulateDoubleBreak;
+}
+function Oe(e) {
+	let t = e.type.prop(F);
+	if (t) return t;
+	let n = e.firstChild, r;
+	if (n && (r = n.type.prop(o.closedBy))) {
+		let t = e.lastChild, n = t && r.indexOf(t.name) > -1;
+		return (e) => Pe(e, !0, 1, void 0, n && !De(e) ? t.from : void 0);
+	}
+	return e.parent == null ? ke : null;
+}
+function ke() {
+	return 0;
+}
+var Ae = class e extends P {
+	constructor(e, t, n) {
+		super(e.state, e.options), this.base = e, this.pos = t, this.context = n;
+	}
+	get node() {
+		return this.context.node;
+	}
+	static create(t, n, r) {
+		return new e(t, n, r);
+	}
+	get textAfter() {
+		return this.textAfterPos(this.pos);
+	}
+	get baseIndent() {
+		return this.baseIndentFor(this.node);
+	}
+	baseIndentFor(e) {
+		let t = this.state.doc.lineAt(e.from);
+		for (;;) {
+			let n = e.resolve(t.from);
+			for (; n.parent && n.parent.from == n.from;) n = n.parent;
+			if (je(n, e)) break;
+			t = this.state.doc.lineAt(n.from);
+		}
+		return this.lineIndent(t.from);
+	}
+	continue() {
+		return Ee(this.context.next, this.base, this.pos);
+	}
+};
+function je(e, t) {
+	for (let n = t; n; n = n.parent) if (e == n) return !0;
+	return !1;
+}
+function Me(e) {
+	let t = e.node, n = t.childAfter(t.from), r = t.lastChild;
+	if (!n) return null;
+	let i = e.options.simulateBreak, a = e.state.doc.lineAt(n.from), o = i == null || i <= a.from ? a.to : Math.min(a.to, i);
+	for (let e = n.to;;) {
+		let i = t.childAfter(e);
+		if (!i || i == r) return null;
+		if (!i.type.isSkipped) {
+			if (i.from >= o) return null;
+			let e = /^ */.exec(a.text.slice(n.to - a.from))[0].length;
+			return {
+				from: n.from,
+				to: n.to + e
+			};
+		}
+		e = i.to;
+	}
+}
+function Ne({ closing: e, align: t = !0, units: n = 1 }) {
+	return (r) => Pe(r, t, n, e);
+}
+function Pe(e, t, n, r, i) {
+	let a = e.textAfter, o = a.match(/^\s*/)[0].length, s = r && a.slice(o, o + r.length) == r || i == e.pos + o, c = t ? Me(e) : null;
+	return c ? s ? e.column(c.from) : e.column(c.to) : e.baseIndent + (s ? 0 : e.unit * n);
+}
+var Fe = (e) => e.baseIndent;
+function Ie({ except: e, units: t = 1 } = {}) {
+	return (n) => {
+		let r = e && e.test(n.textAfter);
+		return n.baseIndent + (r ? 0 : t * n.unit);
+	};
+}
+var Le = 200;
+function Re() {
+	return p.transactionFilter.of((e) => {
+		if (!e.docChanged || !e.isUserEvent("input.type") && !e.isUserEvent("input.complete")) return e;
+		let t = e.startState.languageDataAt("indentOnInput", e.startState.selection.main.head);
+		if (!t.length) return e;
+		let n = e.newDoc, { head: r } = e.newSelection.main, i = n.lineAt(r);
+		if (r > i.from + Le) return e;
+		let a = n.sliceString(i.from, r);
+		if (!t.some((e) => e.test(a))) return e;
+		let { state: o } = e, s = -1, c = [];
+		for (let { head: e } of o.selection.ranges) {
+			let t = o.doc.lineAt(e);
+			if (t.from == s) continue;
+			s = t.from;
+			let n = N(o, t.from);
+			if (n == null) continue;
+			let r = /^\s*/.exec(t.text)[0], i = M(o, n);
+			r != i && c.push({
+				from: t.from,
+				to: t.from + r.length,
+				insert: i
+			});
+		}
+		return c.length ? [e, {
+			changes: c,
+			sequential: !0
+		}] : e;
+	});
+}
+var I = /*@__PURE__*/ h.define(), L = /*@__PURE__*/ new o();
+function ze(e) {
+	let t = e.firstChild, n = e.lastChild;
+	return t && t.to < n.from ? {
+		from: t.to,
+		to: n.type.isError ? e.to : n.from
+	} : null;
+}
+function Be(e, t, n) {
+	let r = w(e);
+	if (r.length < n) return null;
+	let i = r.resolveStack(n, 1), a = null;
+	for (let o = i; o; o = o.next) {
+		let i = o.node;
+		if (i.to <= n || i.from > n) continue;
+		if (a && i.from < t) break;
+		let s = i.type.prop(L);
+		if (s && (i.to < r.length - 50 || r.length == e.doc.length || !Ve(i))) {
+			let r = s(i, e);
+			r && r.from <= n && r.from >= t && r.to > n && (a = r);
+		}
+	}
+	return a;
+}
+function Ve(e) {
+	let t = e.lastChild;
+	return t && t.to == e.to && t.type.isError;
+}
+function R(e, t, n) {
+	for (let r of e.facet(I)) {
+		let i = r(e, t, n);
+		if (i) return i;
+	}
+	return Be(e, t, n);
+}
+function He(e, t) {
+	let n = t.mapPos(e.from, 1), r = t.mapPos(e.to, -1);
+	return n >= r ? void 0 : {
+		from: n,
+		to: r
+	};
+}
+var z = /*@__PURE__*/ m.define({ map: He }), B = /*@__PURE__*/ m.define({ map: He });
+function V(e) {
+	let t = [];
+	for (let { head: n } of e.state.selection.ranges) t.some((e) => e.from <= n && e.to >= n) || t.push(e.lineBlockAt(n));
+	return t;
+}
+var H = /*@__PURE__*/ ne.define({
+	create() {
+		return y.none;
+	},
+	update(e, t) {
+		t.isUserEvent("delete") && t.changes.iterChangedRanges((t, n) => e = Ue(e, t, n)), e = e.map(t.changes);
+		let n = [];
+		for (let r of t.effects) r.is(z) && !Ge(e, r.value.from, r.value.to) ? n.push(r.value) : r.is(B) && (e = e.update({
+			filter: (e, t) => r.value.from != e || r.value.to != t,
+			filterFrom: r.value.from,
+			filterTo: r.value.to
+		}));
+		if (n.length) {
+			let { preparePlaceholder: r } = t.state.facet(K), i = n.map((e) => (r ? y.replace({ widget: new nt(r(t.state, e)) }) : tt).range(e.from, e.to));
+			e = e.update({ add: i });
+		}
+		return t.selection && (e = Ue(e, t.selection.main.head)), e;
+	},
+	provide: (e) => v.decorations.from(e),
+	toJSON(e, t) {
+		let n = [];
+		return e.between(0, t.doc.length, (e, t) => {
+			n.push(e, t);
+		}), n;
+	},
+	fromJSON(e) {
+		if (!Array.isArray(e) || e.length % 2) throw RangeError("Invalid JSON for fold state");
+		let t = [];
+		for (let n = 0; n < e.length;) {
+			let r = e[n++], i = e[n++];
+			if (typeof r != "number" || typeof i != "number") throw RangeError("Invalid JSON for fold state");
+			t.push(tt.range(r, i));
+		}
+		return y.set(t, !0);
+	}
+});
+function Ue(e, t, n = t) {
+	let r = !1;
+	return e.between(t, n, (e, i) => {
+		e < n && i > t && (r = !0);
+	}), r ? e.update({
+		filterFrom: t,
+		filterTo: n,
+		filter: (e, r) => e >= n || r <= t
+	}) : e;
+}
+function We(e) {
+	return e.field(H, !1) || re.empty;
+}
+function U(e, t, n) {
+	var r;
+	let i = null;
+	return (r = e.field(H, !1)) == null || r.between(t, n, (e, t) => {
+		(!i || i.from > e) && (i = {
+			from: e,
+			to: t
+		});
+	}), i;
+}
+function Ge(e, t, n) {
+	let r = !1;
+	return e.between(t, t, (e, i) => {
+		e == t && i == n && (r = !0);
+	}), r;
+}
+function W(e, t) {
+	return e.field(H, !1) ? t : t.concat(m.appendConfig.of(q()));
+}
+var Ke = (e) => {
+	for (let t of V(e)) {
+		let n = R(e.state, t.from, t.to);
+		if (n) return e.dispatch({ effects: W(e.state, [z.of(n), G(e, n)]) }), !0;
+	}
+	return !1;
+}, qe = (e) => {
+	if (!e.state.field(H, !1)) return !1;
+	let t = [];
+	for (let n of V(e)) {
+		let r = U(e.state, n.from, n.to);
+		r && t.push(B.of(r), G(e, r, !1));
+	}
+	return t.length && e.dispatch({ effects: t }), t.length > 0;
+};
+function G(e, t, n = !0) {
+	let r = e.state.doc.lineAt(t.from).number, i = e.state.doc.lineAt(t.to).number;
+	return v.announce.of(`${e.state.phrase(n ? "Folded lines" : "Unfolded lines")} ${r} ${e.state.phrase("to")} ${i}.`);
+}
+var Je = (e) => {
+	let { state: t } = e, n = [];
+	for (let r = 0; r < t.doc.length;) {
+		let i = e.lineBlockAt(r), a = R(t, i.from, i.to);
+		a && n.push(z.of(a)), r = (a ? e.lineBlockAt(a.to) : i).to + 1;
+	}
+	return n.length && e.dispatch({ effects: W(e.state, n) }), !!n.length;
+}, Ye = (e) => {
+	let t = e.state.field(H, !1);
+	if (!t || !t.size) return !1;
+	let n = [];
+	return t.between(0, e.state.doc.length, (e, t) => {
+		n.push(B.of({
+			from: e,
+			to: t
+		}));
+	}), e.dispatch({ effects: n }), !0;
+};
+function Xe(e, t) {
+	for (let n = t;;) {
+		let r = R(e.state, n.from, n.to);
+		if (r && r.to > t.from) return r;
+		if (!n.from) return null;
+		n = e.lineBlockAt(n.from - 1);
+	}
+}
+var Ze = (e) => {
+	let t = [];
+	for (let n of V(e)) {
+		let r = U(e.state, n.from, n.to);
+		if (r) t.push(B.of(r), G(e, r, !1));
+		else {
+			let r = Xe(e, n);
+			r && t.push(z.of(r), G(e, r));
+		}
+	}
+	return t.length > 0 && e.dispatch({ effects: W(e.state, t) }), !!t.length;
+}, Qe = [
+	{
+		key: "Ctrl-Shift-[",
+		mac: "Cmd-Alt-[",
+		run: Ke
+	},
+	{
+		key: "Ctrl-Shift-]",
+		mac: "Cmd-Alt-]",
+		run: qe
+	},
+	{
+		key: "Ctrl-Alt-[",
+		run: Je
+	},
+	{
+		key: "Ctrl-Alt-]",
+		run: Ye
+	}
+], $e = {
+	placeholderDOM: null,
+	preparePlaceholder: null,
+	placeholderText: "…"
+}, K = /*@__PURE__*/ h.define({ combine(e) {
+	return ie(e, $e);
+} });
+function q(e) {
+	let t = [H, at];
+	return e && t.push(K.of(e)), t;
+}
+function et(e, t) {
+	let { state: n } = e, r = n.facet(K), i = (t) => {
+		let n = e.lineBlockAt(e.posAtDOM(t.target)), r = U(e.state, n.from, n.to);
+		r && e.dispatch({ effects: B.of(r) }), t.preventDefault();
+	};
+	if (r.placeholderDOM) return r.placeholderDOM(e, i, t);
+	let a = document.createElement("span");
+	return a.textContent = r.placeholderText, a.setAttribute("aria-label", n.phrase("folded code")), a.title = n.phrase("unfold"), a.className = "cm-foldPlaceholder", a.onclick = i, a;
+}
+var tt = /*@__PURE__*/ y.replace({ widget: /*@__PURE__*/ new class extends ce {
+	toDOM(e) {
+		return et(e, null);
+	}
+}() }), nt = class extends ce {
+	constructor(e) {
+		super(), this.value = e;
+	}
+	eq(e) {
+		return this.value == e.value;
+	}
+	toDOM(e) {
+		return et(e, this.value);
+	}
+}, rt = {
+	openText: "⌄",
+	closedText: "›",
+	markerDOM: null,
+	domEventHandlers: {},
+	foldingChanged: () => !1
+}, J = class extends oe {
+	constructor(e, t) {
+		super(), this.config = e, this.open = t;
+	}
+	eq(e) {
+		return this.config == e.config && this.open == e.open;
+	}
+	toDOM(e) {
+		if (this.config.markerDOM) return this.config.markerDOM(this.open);
+		let t = document.createElement("span");
+		return t.textContent = this.open ? this.config.openText : this.config.closedText, t.title = e.state.phrase(this.open ? "Fold line" : "Unfold line"), t;
+	}
+};
+function it(e = {}) {
+	let t = {
+		...rt,
+		...e
+	}, n = new J(t, !0), r = new J(t, !1), i = g.fromClass(class {
+		constructor(e) {
+			this.from = e.viewport.from, this.markers = this.buildMarkers(e);
+		}
+		update(e) {
+			(e.docChanged || e.viewportChanged || e.startState.facet(k) != e.state.facet(k) || e.startState.field(H, !1) != e.state.field(H, !1) || w(e.startState) != w(e.state) || t.foldingChanged(e)) && (this.markers = this.buildMarkers(e.view));
+		}
+		buildMarkers(e) {
+			let t = new f();
+			for (let i of e.viewportLineBlocks) {
+				let a = U(e.state, i.from, i.to) ? r : R(e.state, i.from, i.to) ? n : null;
+				a && t.add(i.from, i.from, a);
+			}
+			return t.finish();
+		}
+	}), { domEventHandlers: a } = t;
+	return [
+		i,
+		se({
+			class: "cm-foldGutter",
+			markers(e) {
+				return e.plugin(i)?.markers || re.empty;
+			},
+			initialSpacer() {
+				return new J(t, !1);
+			},
+			domEventHandlers: {
+				...a,
+				click: (e, t, n) => {
+					if (a.click && a.click(e, t, n)) return !0;
+					let r = U(e.state, t.from, t.to);
+					if (r) return e.dispatch({ effects: B.of(r) }), !0;
+					let i = R(e.state, t.from, t.to);
+					return i ? (e.dispatch({ effects: z.of(i) }), !0) : !1;
+				}
+			}
+		}),
+		q()
+	];
+}
+var at = /*@__PURE__*/ v.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"
+	}
+}), Y = class e {
+	constructor(e, n) {
+		this.specs = e;
+		let r;
+		function i(e) {
+			let t = ae.newName();
+			return (r ||= Object.create(null))["." + t] = e, t;
+		}
+		let a = typeof n.all == "string" ? n.all : n.all ? i(n.all) : void 0, o = n.scope;
+		this.scope = o instanceof C ? (e) => e.prop(b) == o.data : o ? (e) => e == o : void 0, this.style = t(e.map((e) => ({
+			tag: e.tag,
+			class: e.class || i(Object.assign({}, e, { tag: null }))
+		})), { all: a }).style, this.module = r ? new ae(r) : null, this.themeType = n.themeType;
+	}
+	static define(t, n) {
+		return new e(t, n || {});
+	}
+}, ot = /*@__PURE__*/ h.define(), st = /*@__PURE__*/ h.define({ combine(e) {
+	return e.length ? [e[0]] : null;
+} });
+function X(e) {
+	let t = e.facet(ot);
+	return t.length ? t : e.facet(st);
+}
+function ct(e, t) {
+	let n = [dt], r;
+	return e instanceof Y && (e.module && n.push(v.styleModule.of(e.module)), r = e.themeType), t?.fallback ? n.push(st.of(e)) : r ? n.push(ot.computeN([v.darkTheme], (t) => t.facet(v.darkTheme) == (r == "dark") ? [e] : [])) : n.push(ot.of(e)), n;
+}
+function lt(e, t, n) {
+	let r = X(e), i = null;
+	if (r) {
+		for (let e of r) if (!e.scope || n && e.scope(n)) {
+			let n = e.style(t);
+			n && (i = i ? i + " " + n : n);
+		}
+	}
+	return i;
+}
+var ut = class {
+	constructor(e) {
+		this.markCache = Object.create(null), this.tree = w(e.state), this.decorations = this.buildDeco(e, X(e.state)), this.decoratedTo = e.viewport.to;
+	}
+	update(e) {
+		let t = w(e.state), n = X(e.state), r = n != X(e.startState), { viewport: i } = e.view, a = e.changes.mapPos(this.decoratedTo, 1);
+		t.length < i.to && !r && t.type == this.tree.type && a >= i.to ? (this.decorations = this.decorations.map(e.changes), this.decoratedTo = a) : (t != this.tree || e.viewportChanged || r) && (this.tree = t, this.decorations = this.buildDeco(e.view, n), this.decoratedTo = i.to);
+	}
+	buildDeco(e, t) {
+		if (!t || !this.tree.length) return y.none;
+		let n = new f();
+		for (let { from: r, to: i } of e.visibleRanges) u(this.tree, t, (e, t, r) => {
+			n.add(e, t, this.markCache[r] || (this.markCache[r] = y.mark({ class: r })));
+		}, r, i);
+		return n.finish();
+	}
+}, dt = /*@__PURE__*/ te.high(/*@__PURE__*/ g.fromClass(ut, { decorations: (e) => e.decorations })), ft = /*@__PURE__*/ Y.define([
+	{
+		tag: c.meta,
+		color: "#404740"
+	},
+	{
+		tag: c.link,
+		textDecoration: "underline"
+	},
+	{
+		tag: c.heading,
+		textDecoration: "underline",
+		fontWeight: "bold"
+	},
+	{
+		tag: c.emphasis,
+		fontStyle: "italic"
+	},
+	{
+		tag: c.strong,
+		fontWeight: "bold"
+	},
+	{
+		tag: c.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: c.keyword,
+		color: "#708"
+	},
+	{
+		tag: [
+			c.atom,
+			c.bool,
+			c.url,
+			c.contentSeparator,
+			c.labelName
+		],
+		color: "#219"
+	},
+	{
+		tag: [c.literal, c.inserted],
+		color: "#164"
+	},
+	{
+		tag: [c.string, c.deleted],
+		color: "#a11"
+	},
+	{
+		tag: [
+			c.regexp,
+			c.escape,
+			/*@__PURE__*/ c.special(c.string)
+		],
+		color: "#e40"
+	},
+	{
+		tag: /*@__PURE__*/ c.definition(c.variableName),
+		color: "#00f"
+	},
+	{
+		tag: /*@__PURE__*/ c.local(c.variableName),
+		color: "#30a"
+	},
+	{
+		tag: [c.typeName, c.namespace],
+		color: "#085"
+	},
+	{
+		tag: c.className,
+		color: "#167"
+	},
+	{
+		tag: [/*@__PURE__*/ c.special(c.variableName), c.macroName],
+		color: "#256"
+	},
+	{
+		tag: /*@__PURE__*/ c.definition(c.propertyName),
+		color: "#00c"
+	},
+	{
+		tag: c.comment,
+		color: "#940"
+	},
+	{
+		tag: c.invalid,
+		color: "#f00"
+	}
+]), pt = /*@__PURE__*/ v.baseTheme({
+	"&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+	"&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+}), mt = 1e4, ht = "()[]{}", gt = /*@__PURE__*/ h.define({ combine(e) {
+	return ie(e, {
+		afterCursor: !0,
+		brackets: ht,
+		maxScanDistance: mt,
+		renderMatch: yt
+	});
+} }), _t = /*@__PURE__*/ y.mark({ class: "cm-matchingBracket" }), vt = /*@__PURE__*/ y.mark({ class: "cm-nonmatchingBracket" });
+function yt(e) {
+	let t = [], n = e.matched ? _t : vt;
+	return t.push(n.range(e.start.from, e.start.to)), e.end && t.push(n.range(e.end.from, e.end.to)), t;
+}
+function bt(e) {
+	let t = [], n = e.facet(gt);
+	for (let r of e.selection.ranges) {
+		if (!r.empty) continue;
+		let i = Z(e, r.head, -1, n) || r.head > 0 && Z(e, r.head - 1, 1, n) || n.afterCursor && (Z(e, r.head, 1, n) || r.head < e.doc.length && Z(e, r.head + 1, -1, n));
+		i && (t = t.concat(n.renderMatch(i, e)));
+	}
+	return y.set(t, !0);
+}
+var xt = [/* @__PURE__ */ g.fromClass(class {
+	constructor(e) {
+		this.paused = !1, this.decorations = bt(e.state);
+	}
+	update(e) {
+		(e.docChanged || e.selectionSet || this.paused) && (e.view.composing ? (this.decorations = this.decorations.map(e.changes), this.paused = !0) : (this.decorations = bt(e.state), this.paused = !1));
+	}
+}, { decorations: (e) => e.decorations }), pt];
+function St(e = {}) {
+	return [gt.of(e), xt];
+}
+var Ct = /*@__PURE__*/ new o();
+function wt(e, t, n) {
+	let r = e.prop(t < 0 ? o.openedBy : o.closedBy);
+	if (r) return r;
+	if (e.name.length == 1) {
+		let r = n.indexOf(e.name);
+		if (r > -1 && r % 2 == +(t < 0)) return [n[r + t]];
+	}
+	return null;
+}
+function Tt(e) {
+	let t = e.type.prop(Ct);
+	return t ? t(e.node) : e;
+}
+function Z(e, t, n, r = {}) {
+	let i = r.maxScanDistance || mt, a = r.brackets || ht, o = w(e), s = o.resolveInner(t, n);
+	for (let r = s; r; r = r.parent) {
+		let i = wt(r.type, n, a);
+		if (i && r.from < r.to) {
+			let o = Tt(r);
+			if (o && (n > 0 ? t >= o.from && t < o.to : t > o.from && t <= o.to)) return Et(e, t, n, r, o, i, a);
+		}
+	}
+	return Dt(e, t, n, o, s.type, i, a);
+}
+function Et(e, t, n, r, i, a, o) {
+	let s = r.parent, c = {
+		from: i.from,
+		to: i.to
+	}, l = 0, u = s?.cursor();
+	if (u && (n < 0 ? u.childBefore(r.from) : u.childAfter(r.to))) do
+		if (n < 0 ? u.to <= r.from : u.from >= r.to) {
+			if (l == 0 && a.indexOf(u.type.name) > -1 && u.from < u.to) {
+				let e = Tt(u);
+				return {
+					start: c,
+					end: e ? {
+						from: e.from,
+						to: e.to
+					} : void 0,
+					matched: !0
+				};
+			}
+			if (wt(u.type, n, o)) l++;
+			else if (wt(u.type, -n, o)) {
+				if (l == 0) {
+					let e = Tt(u);
+					return {
+						start: c,
+						end: e && e.from < e.to ? {
+							from: e.from,
+							to: e.to
+						} : void 0,
+						matched: !1
+					};
+				}
+				l--;
+			}
+		}
+	while (n < 0 ? u.prevSibling() : u.nextSibling());
+	return {
+		start: c,
+		matched: !1
+	};
+}
+function Dt(e, t, n, r, i, a, o) {
+	if (n < 0 ? !t : t == e.doc.length) return null;
+	let s = n < 0 ? e.sliceDoc(t - 1, t) : e.sliceDoc(t, t + 1), c = o.indexOf(s);
+	if (c < 0 || c % 2 == 0 != n > 0) return null;
+	let l = {
+		from: n < 0 ? t - 1 : t,
+		to: n > 0 ? t + 1 : t
+	}, u = e.doc.iterRange(t, n > 0 ? e.doc.length : 0), d = 0;
+	for (let e = 0; !u.next().done && e <= a;) {
+		let a = u.value;
+		n < 0 && (e += a.length);
+		let s = t + e * n;
+		for (let e = n > 0 ? 0 : a.length - 1, t = n > 0 ? a.length : -1; e != t; e += n) {
+			let t = o.indexOf(a[e]);
+			if (!(t < 0 || r.resolveInner(s + e, 1).type != i)) {
+				if (t % 2 == 0 == n > 0) d++;
+				else if (d == 1) return {
+					start: l,
+					end: {
+						from: s + e,
+						to: s + e + 1
+					},
+					matched: t >> 1 == c >> 1
+				};
+				else d--;
+			}
+		}
+		n > 0 && (e += a.length);
+	}
+	return u.done ? {
+		start: l,
+		matched: !1
+	} : null;
+}
+function Ot(e, t, n, r = 0, i = 0) {
+	t ?? (t = e.search(/[^\s\u00a0]/), t == -1 && (t = e.length));
+	let a = i;
+	for (let i = r; i < t; i++) e.charCodeAt(i) == 9 ? a += n - a % n : a++;
+	return a;
+}
+var kt = class {
+	constructor(e, t, n, r) {
+		this.string = e, this.tabSize = t, this.indentUnit = n, this.overrideIndent = r, this.pos = 0, this.start = 0, this.lastColumnPos = 0, this.lastColumnValue = 0;
+	}
+	eol() {
+		return this.pos >= this.string.length;
+	}
+	sol() {
+		return this.pos == 0;
+	}
+	peek() {
+		return this.string.charAt(this.pos) || void 0;
+	}
+	next() {
+		if (this.pos < this.string.length) return this.string.charAt(this.pos++);
+	}
+	eat(e) {
+		let t = this.string.charAt(this.pos), n;
+		if (n = typeof e == "string" ? t == e : t && (e instanceof RegExp ? e.test(t) : e(t)), n) return ++this.pos, t;
+	}
+	eatWhile(e) {
+		let t = this.pos;
+		for (; this.eat(e););
+		return this.pos > t;
+	}
+	eatSpace() {
+		let e = this.pos;
+		for (; /[\s\u00a0]/.test(this.string.charAt(this.pos));) ++this.pos;
+		return this.pos > e;
+	}
+	skipToEnd() {
+		this.pos = this.string.length;
+	}
+	skipTo(e) {
+		let t = this.string.indexOf(e, this.pos);
+		if (t > -1) return this.pos = t, !0;
+	}
+	backUp(e) {
+		this.pos -= e;
+	}
+	column() {
+		return this.lastColumnPos < this.start && (this.lastColumnValue = Ot(this.string, this.start, this.tabSize, this.lastColumnPos, this.lastColumnValue), this.lastColumnPos = this.start), this.lastColumnValue;
+	}
+	indentation() {
+		return this.overrideIndent ?? Ot(this.string, null, this.tabSize);
+	}
+	match(e, t, n) {
+		if (typeof e == "string") {
+			let r = (e) => n ? e.toLowerCase() : e;
+			return r(this.string.substr(this.pos, e.length)) == r(e) ? (t !== !1 && (this.pos += e.length), !0) : null;
+		}
+		{
+			let n = this.string.slice(this.pos).match(e);
+			return n && n.index > 0 ? null : (n && t !== !1 && (this.pos += n[0].length), n);
+		}
+	}
+	current() {
+		return this.string.slice(this.start, this.pos);
+	}
+};
+function At(e) {
+	return {
+		name: e.name || "",
+		token: e.token,
+		blankLine: e.blankLine || (() => {}),
+		startState: e.startState || (() => !0),
+		copyState: e.copyState || jt,
+		indent: e.indent || (() => null),
+		languageData: e.languageData || {},
+		tokenTable: e.tokenTable || zt,
+		mergeTokens: e.mergeTokens !== !1
+	};
+}
+function jt(e) {
+	if (typeof e != "object") return e;
+	let t = {};
+	for (let n in e) {
+		let r = e[n];
+		t[n] = r instanceof Array ? r.slice() : r;
+	}
+	return t;
+}
+var Mt = /*@__PURE__*/ new WeakMap(), Nt = class e extends C {
+	constructor(e) {
+		let t = x(e.languageData), n = At(e), r, i = new class extends l {
+			createParse(e, t, n) {
+				return new Lt(r, e, t, n);
+			}
+		}();
+		super(t, i, [], e.name), this.topNode = Jt(t, this), r = this, this.streamParser = n, this.stateAfter = new o({ perNode: !0 }), this.tokenTable = e.tokenTable ? new Wt(n.tokenTable) : Gt;
+	}
+	static define(t) {
+		return new e(t);
+	}
+	getIndent(e) {
+		let t, { overrideIndentation: n } = e.options;
+		n && (t = Mt.get(e.state), t != null && t < e.pos - 1e4 && (t = void 0));
+		let r = Pt(this, e.node.tree, e.node.from, e.node.from, t ?? e.pos), i, a;
+		if (r ? (a = r.state, i = r.pos + 1) : (a = this.streamParser.startState(e.unit), i = e.node.from), e.pos - i > 1e4) return null;
+		for (; i < e.pos;) {
+			let t = e.state.doc.lineAt(i), r = Math.min(e.pos, t.to);
+			if (t.length) {
+				let i = n ? n(t.from) : -1, o = new kt(t.text, e.state.tabSize, e.unit, i < 0 ? void 0 : i);
+				for (; o.pos < r - t.from;) Rt(this.streamParser.token, o, a);
+			} else this.streamParser.blankLine(a, e.unit);
+			if (r == e.pos) break;
+			i = t.to + 1;
+		}
+		let o = e.lineAt(e.pos);
+		return n && t == null && Mt.set(e.state, o.from), this.streamParser.indent(a, /^\s*(.*)/.exec(o.text)[1], e);
+	}
+	get allowsNesting() {
+		return !1;
+	}
+};
+function Pt(e, t, n, r, i) {
+	let a = n >= r && n + t.length <= i && t.prop(e.stateAfter);
+	if (a) return {
+		state: e.streamParser.copyState(a),
+		pos: n + t.length
+	};
+	for (let a = t.children.length - 1; a >= 0; a--) {
+		let o = t.children[a], c = n + t.positions[a], l = o instanceof s && c < i && Pt(e, o, c, r, i);
+		if (l) return l;
+	}
+	return null;
+}
+function Ft(e, t, n, r, i) {
+	if (i && n <= 0 && r >= t.length) return t;
+	!i && n == 0 && t.type == e.topNode && (i = !0);
+	for (let a = t.children.length - 1; a >= 0; a--) {
+		let o = t.positions[a], c = t.children[a], l;
+		if (o < r && c instanceof s) {
+			if (!(l = Ft(e, c, n - o, r - o, i))) break;
+			return i ? new s(t.type, t.children.slice(0, a).concat(l), t.positions.slice(0, a + 1), o + l.length) : l;
+		}
+	}
+	return null;
+}
+function It(e, t, n, r, i) {
+	for (let i of t) {
+		let t = i.from + (i.openStart ? 25 : 0), a = i.to - (i.openEnd ? 25 : 0), o = t <= n && a > n && Pt(e, i.tree, 0 - i.offset, n, a), s;
+		if (o && o.pos <= r && (s = Ft(e, i.tree, n + i.offset, o.pos + i.offset, !1))) return {
+			state: o.state,
+			tree: s
+		};
+	}
+	return {
+		state: e.streamParser.startState(i ? j(i) : 4),
+		tree: s.empty
+	};
+}
+var Lt = class {
+	constructor(e, t, n, r) {
+		this.lang = e, this.input = t, this.fragments = n, this.ranges = r, this.stoppedAt = null, this.chunks = [], this.chunkPos = [], this.chunk = [], this.chunkReused = void 0, this.rangeIndex = 0, this.to = r[r.length - 1].to;
+		let i = E.get(), a = r[0].from, { state: o, tree: s } = It(e, n, a, this.to, i?.state);
+		this.state = o, this.parsedPos = this.chunkStart = a + s.length;
+		for (let e = 0; e < s.children.length; e++) this.chunks.push(s.children[e]), this.chunkPos.push(s.positions[e]);
+		i && this.parsedPos < i.viewport.from - 1e5 && r.some((e) => e.from <= i.viewport.from && e.to >= i.viewport.from) && (this.state = this.lang.streamParser.startState(j(i.state)), i.skipUntilInView(this.parsedPos, i.viewport.from), this.parsedPos = i.viewport.from), this.moveRangeIndex();
+	}
+	advance() {
+		let e = E.get(), t = this.stoppedAt == null ? this.to : Math.min(this.to, this.stoppedAt), n = Math.min(t, this.chunkStart + 512);
+		for (e && (n = Math.min(n, e.viewport.to)); this.parsedPos < n;) this.parseLine(e);
+		return this.chunkStart < this.parsedPos && this.finishChunk(), this.parsedPos >= t ? this.finish() : e && this.parsedPos >= e.viewport.to ? (e.skipUntilInView(this.parsedPos, t), this.finish()) : null;
+	}
+	stopAt(e) {
+		this.stoppedAt = e;
+	}
+	lineAfter(e) {
+		let t = this.input.chunk(e);
+		if (this.input.lineChunks) t == "\n" && (t = "");
+		else {
+			let e = t.indexOf("\n");
+			e > -1 && (t = t.slice(0, e));
+		}
+		return e + t.length <= this.to ? t : t.slice(0, this.to - e);
+	}
+	nextLine() {
+		let e = this.parsedPos, t = this.lineAfter(e), n = e + t.length;
+		for (let e = this.rangeIndex;;) {
+			let r = this.ranges[e].to;
+			if (r >= n || (t = t.slice(0, r - (n - t.length)), e++, e == this.ranges.length)) break;
+			let i = this.ranges[e].from, a = this.lineAfter(i);
+			t += a, n = i + a.length;
+		}
+		return {
+			line: t,
+			end: n
+		};
+	}
+	skipGapsTo(e, t, n) {
+		for (;;) {
+			let r = this.ranges[this.rangeIndex].to, i = e + t;
+			if (n > 0 ? r > i : r >= i) break;
+			let a = this.ranges[++this.rangeIndex].from;
+			t += a - r;
+		}
+		return t;
+	}
+	moveRangeIndex() {
+		for (; this.ranges[this.rangeIndex].to < this.parsedPos;) this.rangeIndex++;
+	}
+	emitToken(e, t, n, r) {
+		let i = 4;
+		if (this.ranges.length > 1) {
+			r = this.skipGapsTo(t, r, 1), t += r;
+			let e = this.chunk.length;
+			r = this.skipGapsTo(n, r, -1), n += r, i += this.chunk.length - e;
+		}
+		let a = this.chunk.length - 4;
+		return this.lang.streamParser.mergeTokens && i == 4 && a >= 0 && this.chunk[a] == e && this.chunk[a + 2] == t ? this.chunk[a + 2] = n : this.chunk.push(e, t, n, i), r;
+	}
+	parseLine(e) {
+		let { line: t, end: n } = this.nextLine(), r = 0, { streamParser: i } = this.lang, a = new kt(t, e ? e.state.tabSize : 4, e ? j(e.state) : 2);
+		if (a.eol()) i.blankLine(this.state, a.indentUnit);
+		else for (; !a.eol();) {
+			let e = Rt(i.token, a, this.state);
+			if (e && (r = this.emitToken(this.lang.tokenTable.resolve(e), this.parsedPos + a.start, this.parsedPos + a.pos, r)), a.start > 1e4) break;
+		}
+		this.parsedPos = n, this.moveRangeIndex(), this.parsedPos < this.to && this.parsedPos++;
+	}
+	finishChunk() {
+		let e = s.build({
+			buffer: this.chunk,
+			start: this.chunkStart,
+			length: this.parsedPos - this.chunkStart,
+			nodeSet: Bt,
+			topID: 0,
+			maxBufferLength: 512,
+			reused: this.chunkReused
+		});
+		e = new s(e.type, e.children, e.positions, e.length, [[this.lang.stateAfter, this.lang.streamParser.copyState(this.state)]]), this.chunks.push(e), this.chunkPos.push(this.chunkStart - this.ranges[0].from), this.chunk = [], this.chunkReused = void 0, this.chunkStart = this.parsedPos;
+	}
+	finish() {
+		return new s(this.lang.topNode, this.chunks, this.chunkPos, this.parsedPos - this.ranges[0].from).balance();
+	}
+};
+function Rt(e, t, n) {
+	t.start = t.pos;
+	for (let r = 0; r < 10; r++) {
+		let r = e(t, n);
+		if (t.pos > t.start) return r;
+	}
+	throw Error("Stream parser failed to advance stream.");
+}
+var zt = /*@__PURE__*/ Object.create(null), Q = [r.none], Bt = /*@__PURE__*/ new d(Q), Vt = [], Ht = /*@__PURE__*/ Object.create(null), Ut = /*@__PURE__*/ Object.create(null);
+for (let [e, t] 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"]
+]) Ut[e] = /*@__PURE__*/ qt(zt, t);
+var Wt = class {
+	constructor(e) {
+		this.extra = e, this.table = Object.assign(Object.create(null), Ut);
+	}
+	resolve(e) {
+		return e ? this.table[e] || (this.table[e] = qt(this.extra, e)) : 0;
+	}
+}, Gt = /*@__PURE__*/ new Wt(zt);
+function Kt(e, t) {
+	Vt.indexOf(e) > -1 || (Vt.push(e), console.warn(t));
+}
+function qt(e, t) {
+	let n = [];
+	for (let r of t.split(" ")) {
+		let t = [];
+		for (let n of r.split(".")) {
+			let r = e[n] || c[n];
+			r ? typeof r == "function" ? t.length ? t = t.map(r) : Kt(n, `Modifier ${n} used at start of tag`) : t.length ? Kt(n, `Tag ${n} used as modifier`) : t = Array.isArray(r) ? r : [r] : Kt(n, `Unknown highlighting tag ${n}`);
+		}
+		for (let e of t) n.push(e);
+	}
+	if (!n.length) return 0;
+	let i = t.replace(/ /g, "_"), o = i + " " + n.map((e) => e.id), s = Ht[o];
+	if (s) return s.id;
+	let l = Ht[o] = r.define({
+		id: Q.length,
+		name: i,
+		props: [a({ [i]: n })]
+	});
+	return Q.push(l), l.id;
+}
+function Jt(e, t) {
+	let n = r.define({
+		id: Q.length,
+		name: "Document",
+		props: [b.add(() => e), F.add(() => (e) => t.getIndent(e))],
+		top: !0
+	});
+	return Q.push(n), n;
+}
+function Yt(e) {
+	return e.length <= 4096 && /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\ufb50-\ufdff]/.test(e);
+}
+function Xt(e) {
+	for (let t = e.iter(); !t.next().done;) if (Yt(t.value)) return !0;
+	return !1;
+}
+function Zt(e) {
+	let t = !1;
+	return e.iterChanges((e, n, r, i, a) => {
+		!t && Xt(a) && (t = !0);
+	}), t;
+}
+var $ = /*@__PURE__*/ h.define({ combine: (e) => e.some((e) => e) });
+function Qt(e = {}) {
+	let t = [$t];
+	return e.alwaysIsolate && t.push($.of(!0)), t;
+}
+var $t = /*@__PURE__*/ g.fromClass(class {
+	constructor(e) {
+		this.always = e.state.facet($) || e.textDirection != _.LTR || e.state.facet(v.perLineTextDirection), this.hasRTL = !this.always && Xt(e.state.doc), this.tree = w(e.state), this.decorations = this.always || this.hasRTL ? en(e, this.tree, this.always) : y.none;
+	}
+	update(e) {
+		let t = e.state.facet($) || e.view.textDirection != _.LTR || e.state.facet(v.perLineTextDirection);
+		if (!t && !this.hasRTL && Zt(e.changes) && (this.hasRTL = !0), !t && !this.hasRTL) return;
+		let n = w(e.state);
+		(t != this.always || n != this.tree || e.docChanged || e.viewportChanged) && (this.tree = n, this.always = t, this.decorations = en(e.view, n, t));
+	}
+}, { provide: (e) => {
+	function t(t) {
+		return t.plugin(e)?.decorations ?? y.none;
+	}
+	return [v.outerDecorations.of(t), te.lowest(v.bidiIsolatedRanges.of(t))];
+} });
+function en(e, t, n) {
+	let r = new f(), i = e.visibleRanges;
+	n || (i = tn(i, e.state.doc));
+	for (let { from: e, to: n } of i) t.iterate({
+		enter: (e) => {
+			let t = e.type.prop(o.isolate);
+			t && r.add(e.from, e.to, nn[t]);
+		},
+		from: e,
+		to: n
+	});
+	return r.finish();
+}
+function tn(e, t) {
+	let n = t.iter(), r = 0, i = [], a = null;
+	for (let { from: t, to: o } of e) if (!(a && a.to > t && (t = a.to, t >= o))) for (r + n.value.length < t && (n.next(t - (r + n.value.length)), r = t);;) {
+		let e = r, t = r + n.value.length;
+		if (!n.lineBreak && Yt(n.value) && (a && a.to > e - 10 ? a.to = Math.min(o, t) : i.push(a = {
+			from: e,
+			to: Math.min(o, t)
+		})), t >= o) break;
+		r = t, n.next();
+	}
+	return i;
+}
+var nn = {
+	rtl: /*@__PURE__*/ y.mark({
+		class: "cm-iso",
+		inclusive: !0,
+		attributes: { dir: "rtl" },
+		bidiIsolate: _.RTL
+	}),
+	ltr: /*@__PURE__*/ y.mark({
+		class: "cm-iso",
+		inclusive: !0,
+		attributes: { dir: "ltr" },
+		bidiIsolate: _.LTR
+	}),
+	auto: /*@__PURE__*/ y.mark({
+		class: "cm-iso",
+		inclusive: !0,
+		attributes: { dir: "auto" },
+		bidiIsolate: null
+	})
+};
+//#endregion
+export { ct as A, F as C, b as D, A as E, Z as O, N as S, M as T, ze as _, Se as a, I as b, St as c, ft as d, x as f, it as g, Fe as h, C as i, w as j, S as k, Ct as l, ue as m, P as n, xe as o, Ne as p, fe as r, E as s, Y as t, Ie as u, Qe as v, Re as w, j as x, L as y };