@oomol-lab/open-flow 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/browser/dist-DxahK_I8.js

@@ -0,0 +1,2688 @@
+import { b as e, d as t, l as n, m as r, o as i, p as a, s as o, u as s, y as c } from "./dist-Mecbzdl2.js";
+import { S as l, a as u, h as d, i as f, k as p, n as m, o as h, r as g, t as _ } from "./dist-BKuSVKCC.js";
+//#region ../../node_modules/.bun/@lezer+common@1.5.2/node_modules/@lezer/common/dist/index.js
+var ee = 1024, v = 0, y = class {
+	constructor(e, t) {
+		this.from = e, this.to = t;
+	}
+}, b = class {
+	constructor(e = {}) {
+		this.id = v++, this.perNode = !!e.perNode, this.deserialize = e.deserialize || (() => {
+			throw Error("This node type doesn't define a deserialize function");
+		}), this.combine = e.combine || null;
+	}
+	add(e) {
+		if (this.perNode) throw RangeError("Can't add per-node props to node types");
+		return typeof e != "function" && (e = C.match(e)), (t) => {
+			let n = e(t);
+			return n === void 0 ? null : [this, n];
+		};
+	}
+};
+b.closedBy = new b({ deserialize: (e) => e.split(" ") }), b.openedBy = new b({ deserialize: (e) => e.split(" ") }), b.group = new b({ deserialize: (e) => e.split(" ") }), b.isolate = new b({ deserialize: (e) => {
+	if (e && e != "rtl" && e != "ltr" && e != "auto") throw RangeError("Invalid value for isolate: " + e);
+	return e || "auto";
+} }), b.contextHash = new b({ perNode: !0 }), b.lookAhead = new b({ perNode: !0 }), b.mounted = new b({ perNode: !0 });
+var x = class {
+	constructor(e, t, n, r = !1) {
+		this.tree = e, this.overlay = t, this.parser = n, this.bracketed = r;
+	}
+	static get(e) {
+		return e && e.props && e.props[b.mounted.id];
+	}
+}, S = Object.create(null), C = class e {
+	constructor(e, t, n, r = 0) {
+		this.name = e, this.props = t, this.id = n, this.flags = r;
+	}
+	static define(t) {
+		let n = t.props && t.props.length ? Object.create(null) : S, r = !!t.top | (t.skipped ? 2 : 0) | (t.error ? 4 : 0) | (t.name == null ? 8 : 0), i = new e(t.name || "", n, t.id, r);
+		if (t.props) {
+			for (let e of t.props) if (Array.isArray(e) || (e = e(i)), e) {
+				if (e[0].perNode) throw RangeError("Can't store a per-node prop on a node type");
+				n[e[0].id] = e[1];
+			}
+		}
+		return i;
+	}
+	prop(e) {
+		return this.props[e.id];
+	}
+	get isTop() {
+		return (this.flags & 1) > 0;
+	}
+	get isSkipped() {
+		return (this.flags & 2) > 0;
+	}
+	get isError() {
+		return (this.flags & 4) > 0;
+	}
+	get isAnonymous() {
+		return (this.flags & 8) > 0;
+	}
+	is(e) {
+		if (typeof e == "string") {
+			if (this.name == e) return !0;
+			let t = this.prop(b.group);
+			return t ? t.indexOf(e) > -1 : !1;
+		}
+		return this.id == e;
+	}
+	static match(e) {
+		let t = Object.create(null);
+		for (let n in e) for (let r of n.split(" ")) t[r] = e[n];
+		return (e) => {
+			for (let n = e.prop(b.group), r = -1; r < (n ? n.length : 0); r++) {
+				let i = t[r < 0 ? e.name : n[r]];
+				if (i) return i;
+			}
+		};
+	}
+};
+C.none = new C("", Object.create(null), 0, 8);
+var te = class e {
+	constructor(e) {
+		this.types = e;
+		for (let t = 0; t < e.length; t++) if (e[t].id != t) throw RangeError("Node type ids should correspond to array positions when creating a node set");
+	}
+	extend(...t) {
+		let n = [];
+		for (let e of this.types) {
+			let r = null;
+			for (let n of t) {
+				let t = n(e);
+				if (t) {
+					r ||= Object.assign({}, e.props);
+					let n = t[1], i = t[0];
+					i.combine && i.id in r && (n = i.combine(r[i.id], n)), r[i.id] = n;
+				}
+			}
+			n.push(r ? new C(e.name, r, e.id, e.flags) : e);
+		}
+		return new e(n);
+	}
+}, w = /* @__PURE__ */ new WeakMap(), T = /* @__PURE__ */ new WeakMap(), E;
+(function(e) {
+	e[e.ExcludeBuffers = 1] = "ExcludeBuffers", e[e.IncludeAnonymous = 2] = "IncludeAnonymous", e[e.IgnoreMounts = 4] = "IgnoreMounts", e[e.IgnoreOverlays = 8] = "IgnoreOverlays", e[e.EnterBracketed = 16] = "EnterBracketed";
+})(E ||= {});
+var D = class e {
+	constructor(e, t, n, r, i) {
+		if (this.type = e, this.children = t, this.positions = n, this.length = r, this.props = null, i && i.length) {
+			this.props = Object.create(null);
+			for (let [e, t] of i) this.props[typeof e == "number" ? e : e.id] = t;
+		}
+	}
+	toString() {
+		let e = x.get(this);
+		if (e && !e.overlay) return e.tree.toString();
+		let t = "";
+		for (let e of this.children) {
+			let n = e.toString();
+			n && (t && (t += ","), t += n);
+		}
+		return this.type.name ? (/\W/.test(this.type.name) && !this.type.isError ? JSON.stringify(this.type.name) : this.type.name) + (t.length ? "(" + t + ")" : "") : t;
+	}
+	cursor(e = 0) {
+		return new M(this.topNode, e);
+	}
+	cursorAt(e, t = 0, n = 0) {
+		let r = new M(w.get(this) || this.topNode);
+		return r.moveTo(e, t), w.set(this, r._tree), r;
+	}
+	get topNode() {
+		return new A(this, 0, 0, null);
+	}
+	resolve(e, t = 0) {
+		let n = k(w.get(this) || this.topNode, e, t, !1);
+		return w.set(this, n), n;
+	}
+	resolveInner(e, t = 0) {
+		let n = k(T.get(this) || this.topNode, e, t, !0);
+		return T.set(this, n), n;
+	}
+	resolveStack(e, t = 0) {
+		return ue(this, e, t);
+	}
+	iterate(e) {
+		let { enter: t, leave: n, from: r = 0, to: i = this.length } = e, a = e.mode || 0, o = (a & E.IncludeAnonymous) > 0;
+		for (let e = this.cursor(a | E.IncludeAnonymous);;) {
+			let a = !1;
+			if (e.from <= i && e.to >= r && (!o && e.type.isAnonymous || t(e) !== !1)) {
+				if (e.firstChild()) continue;
+				a = !0;
+			}
+			for (; a && n && (o || !e.type.isAnonymous) && n(e), !e.nextSibling();) {
+				if (!e.parent()) return;
+				a = !0;
+			}
+		}
+	}
+	prop(e) {
+		return e.perNode ? this.props ? this.props[e.id] : void 0 : this.type.prop(e);
+	}
+	get propValues() {
+		let e = [];
+		if (this.props) for (let t in this.props) e.push([+t, this.props[t]]);
+		return e;
+	}
+	balance(t = {}) {
+		return this.children.length <= 8 ? this : he(C.none, this.children, this.positions, 0, this.children.length, 0, this.length, (t, n, r) => new e(this.type, t, n, r, this.propValues), t.makeTree || ((t, n, r) => new e(C.none, t, n, r)));
+	}
+	static build(e) {
+		return fe(e);
+	}
+};
+D.empty = new D(C.none, [], [], 0);
+var ne = class e {
+	constructor(e, t) {
+		this.buffer = e, this.index = t;
+	}
+	get id() {
+		return this.buffer[this.index - 4];
+	}
+	get start() {
+		return this.buffer[this.index - 3];
+	}
+	get end() {
+		return this.buffer[this.index - 2];
+	}
+	get size() {
+		return this.buffer[this.index - 1];
+	}
+	get pos() {
+		return this.index;
+	}
+	next() {
+		this.index -= 4;
+	}
+	fork() {
+		return new e(this.buffer, this.index);
+	}
+}, O = class e {
+	constructor(e, t, n) {
+		this.buffer = e, this.length = t, this.set = n;
+	}
+	get type() {
+		return C.none;
+	}
+	toString() {
+		let e = [];
+		for (let t = 0; t < this.buffer.length;) e.push(this.childString(t)), t = this.buffer[t + 3];
+		return e.join(",");
+	}
+	childString(e) {
+		let t = this.buffer[e], n = this.buffer[e + 3], r = this.set.types[t], i = r.name;
+		if (/\W/.test(i) && !r.isError && (i = JSON.stringify(i)), e += 4, n == e) return i;
+		let a = [];
+		for (; e < n;) a.push(this.childString(e)), e = this.buffer[e + 3];
+		return i + "(" + a.join(",") + ")";
+	}
+	findChild(e, t, n, r, i) {
+		let { buffer: a } = this, o = -1;
+		for (let s = e; s != t && !(re(i, r, a[s + 1], a[s + 2]) && (o = s, n > 0)); s = a[s + 3]);
+		return o;
+	}
+	slice(t, n, r) {
+		let i = this.buffer, a = new Uint16Array(n - t), o = 0;
+		for (let e = t, s = 0; e < n;) {
+			a[s++] = i[e++], a[s++] = i[e++] - r;
+			let n = a[s++] = i[e++] - r;
+			a[s++] = i[e++] - t, o = Math.max(o, n);
+		}
+		return new e(a, o, this.set);
+	}
+};
+function re(e, t, n, r) {
+	switch (e) {
+		case -2: return n < t;
+		case -1: return r >= t && n < t;
+		case 0: return n < t && r > t;
+		case 1: return n <= t && r > t;
+		case 2: return r > t;
+		case 4: return !0;
+	}
+}
+function k(e, t, n, r) {
+	for (; e.from == e.to || (n < 1 ? e.from >= t : e.from > t) || (n > -1 ? e.to <= t : e.to < t);) {
+		let t = !r && e instanceof A && e.index < 0 ? null : e.parent;
+		if (!t) return e;
+		e = t;
+	}
+	let i = r ? 0 : E.IgnoreOverlays;
+	if (r) for (let r = e, a = r.parent; a; r = a, a = r.parent) r instanceof A && r.index < 0 && a.enter(t, n, i)?.from != r.from && (e = a);
+	for (;;) {
+		let r = e.enter(t, n, i);
+		if (!r) return e;
+		e = r;
+	}
+}
+var ie = class {
+	cursor(e = 0) {
+		return new M(this, e);
+	}
+	getChild(e, t = null, n = null) {
+		let r = ae(this, e, t, n);
+		return r.length ? r[0] : null;
+	}
+	getChildren(e, t = null, n = null) {
+		return ae(this, e, t, n);
+	}
+	resolve(e, t = 0) {
+		return k(this, e, t, !1);
+	}
+	resolveInner(e, t = 0) {
+		return k(this, e, t, !0);
+	}
+	matchContext(e) {
+		return oe(this.parent, e);
+	}
+	enterUnfinishedNodesBefore(e) {
+		let t = this.childBefore(e), n = this;
+		for (; t;) {
+			let e = t.lastChild;
+			if (!e || e.to != t.to) break;
+			e.type.isError && e.from == e.to ? (n = t, t = e.prevSibling) : t = e;
+		}
+		return n;
+	}
+	get node() {
+		return this;
+	}
+	get next() {
+		return this.parent;
+	}
+}, A = class e extends ie {
+	constructor(e, t, n, r) {
+		super(), this._tree = e, this.from = t, this.index = n, this._parent = r;
+	}
+	get type() {
+		return this._tree.type;
+	}
+	get name() {
+		return this._tree.type.name;
+	}
+	get to() {
+		return this.from + this._tree.length;
+	}
+	nextChild(t, n, r, i, a = 0) {
+		for (let o = this;;) {
+			for (let { children: s, positions: c } = o._tree, l = n > 0 ? s.length : -1; t != l; t += n) {
+				let l = s[t], u = c[t] + o.from, d;
+				if (!(!(a & E.EnterBracketed && l instanceof D && (d = x.get(l)) && !d.overlay && d.bracketed && r >= u && r <= u + l.length) && !re(i, r, u, u + l.length))) {
+					if (l instanceof O) {
+						if (a & E.ExcludeBuffers) continue;
+						let e = l.findChild(0, l.buffer.length, n, r - u, i);
+						if (e > -1) return new j(new se(o, l, t, u), null, e);
+					} else if (a & E.IncludeAnonymous || !l.type.isAnonymous || de(l)) {
+						let s;
+						if (!(a & E.IgnoreMounts) && (s = x.get(l)) && !s.overlay) return new e(s.tree, u, t, o);
+						let c = new e(l, u, t, o);
+						return a & E.IncludeAnonymous || !c.type.isAnonymous ? c : c.nextChild(n < 0 ? l.children.length - 1 : 0, n, r, i, a);
+					}
+				}
+			}
+			if (a & E.IncludeAnonymous || !o.type.isAnonymous || (t = o.index >= 0 ? o.index + n : n < 0 ? -1 : o._parent._tree.children.length, o = o._parent, !o)) return null;
+		}
+	}
+	get firstChild() {
+		return this.nextChild(0, 1, 0, 4);
+	}
+	get lastChild() {
+		return this.nextChild(this._tree.children.length - 1, -1, 0, 4);
+	}
+	childAfter(e) {
+		return this.nextChild(0, 1, e, 2);
+	}
+	childBefore(e) {
+		return this.nextChild(this._tree.children.length - 1, -1, e, -2);
+	}
+	prop(e) {
+		return this._tree.prop(e);
+	}
+	enter(t, n, r = 0) {
+		let i;
+		if (!(r & E.IgnoreOverlays) && (i = x.get(this._tree)) && i.overlay) {
+			let a = t - this.from, o = r & E.EnterBracketed && i.bracketed;
+			for (let { from: t, to: r } of i.overlay) if ((n > 0 || o ? t <= a : t < a) && (n < 0 || o ? r >= a : r > a)) return new e(i.tree, i.overlay[0].from + this.from, -1, this);
+		}
+		return this.nextChild(0, 1, t, n, r);
+	}
+	nextSignificantParent() {
+		let e = this;
+		for (; e.type.isAnonymous && e._parent;) e = e._parent;
+		return e;
+	}
+	get parent() {
+		return this._parent ? this._parent.nextSignificantParent() : null;
+	}
+	get nextSibling() {
+		return this._parent && this.index >= 0 ? this._parent.nextChild(this.index + 1, 1, 0, 4) : null;
+	}
+	get prevSibling() {
+		return this._parent && this.index >= 0 ? this._parent.nextChild(this.index - 1, -1, 0, 4) : null;
+	}
+	get tree() {
+		return this._tree;
+	}
+	toTree() {
+		return this._tree;
+	}
+	toString() {
+		return this._tree.toString();
+	}
+};
+function ae(e, t, n, r) {
+	let i = e.cursor(), a = [];
+	if (!i.firstChild()) return a;
+	if (n != null) {
+		for (let e = !1; !e;) if (e = i.type.is(n), !i.nextSibling()) return a;
+	}
+	for (;;) {
+		if (r != null && i.type.is(r)) return a;
+		if (i.type.is(t) && a.push(i.node), !i.nextSibling()) return r == null ? a : [];
+	}
+}
+function oe(e, t, n = t.length - 1) {
+	for (let r = e; n >= 0; r = r.parent) {
+		if (!r) return !1;
+		if (!r.type.isAnonymous) {
+			if (t[n] && t[n] != r.name) return !1;
+			n--;
+		}
+	}
+	return !0;
+}
+var se = class {
+	constructor(e, t, n, r) {
+		this.parent = e, this.buffer = t, this.index = n, this.start = r;
+	}
+}, j = class e extends ie {
+	get name() {
+		return this.type.name;
+	}
+	get from() {
+		return this.context.start + this.context.buffer.buffer[this.index + 1];
+	}
+	get to() {
+		return this.context.start + this.context.buffer.buffer[this.index + 2];
+	}
+	constructor(e, t, n) {
+		super(), this.context = e, this._parent = t, this.index = n, this.type = e.buffer.set.types[e.buffer.buffer[n]];
+	}
+	child(t, n, r) {
+		let { buffer: i } = this.context, a = i.findChild(this.index + 4, i.buffer[this.index + 3], t, n - this.context.start, r);
+		return a < 0 ? null : new e(this.context, this, a);
+	}
+	get firstChild() {
+		return this.child(1, 0, 4);
+	}
+	get lastChild() {
+		return this.child(-1, 0, 4);
+	}
+	childAfter(e) {
+		return this.child(1, e, 2);
+	}
+	childBefore(e) {
+		return this.child(-1, e, -2);
+	}
+	prop(e) {
+		return this.type.prop(e);
+	}
+	enter(t, n, r = 0) {
+		if (r & E.ExcludeBuffers) return null;
+		let { buffer: i } = this.context, a = i.findChild(this.index + 4, i.buffer[this.index + 3], n > 0 ? 1 : -1, t - this.context.start, n);
+		return a < 0 ? null : new e(this.context, this, a);
+	}
+	get parent() {
+		return this._parent || this.context.parent.nextSignificantParent();
+	}
+	externalSibling(e) {
+		return this._parent ? null : this.context.parent.nextChild(this.context.index + e, e, 0, 4);
+	}
+	get nextSibling() {
+		let { buffer: t } = this.context, n = t.buffer[this.index + 3];
+		return n < (this._parent ? t.buffer[this._parent.index + 3] : t.buffer.length) ? new e(this.context, this._parent, n) : this.externalSibling(1);
+	}
+	get prevSibling() {
+		let { buffer: t } = this.context, n = this._parent ? this._parent.index + 4 : 0;
+		return this.index == n ? this.externalSibling(-1) : new e(this.context, this._parent, t.findChild(n, this.index, -1, 0, 4));
+	}
+	get tree() {
+		return null;
+	}
+	toTree() {
+		let e = [], t = [], { buffer: n } = this.context, r = this.index + 4, i = n.buffer[this.index + 3];
+		if (i > r) {
+			let a = n.buffer[this.index + 1];
+			e.push(n.slice(r, i, a)), t.push(0);
+		}
+		return new D(this.type, e, t, this.to - this.from);
+	}
+	toString() {
+		return this.context.buffer.childString(this.index);
+	}
+};
+function ce(e) {
+	if (!e.length) return null;
+	let t = 0, n = e[0];
+	for (let r = 1; r < e.length; r++) {
+		let i = e[r];
+		(i.from > n.from || i.to < n.to) && (n = i, t = r);
+	}
+	let r = n instanceof A && n.index < 0 ? null : n.parent, i = e.slice();
+	return r ? i[t] = r : i.splice(t, 1), new le(i, n);
+}
+var le = class {
+	constructor(e, t) {
+		this.heads = e, this.node = t;
+	}
+	get next() {
+		return ce(this.heads);
+	}
+};
+function ue(e, t, n) {
+	let r = e.resolveInner(t, n), i = null;
+	for (let e = r instanceof A ? r : r.context.parent; e; e = e.parent) if (e.index < 0) {
+		let a = e.parent;
+		(i ||= [r]).push(a.resolve(t, n)), e = a;
+	} else {
+		let a = x.get(e.tree);
+		if (a && a.overlay && a.overlay[0].from <= t && a.overlay[a.overlay.length - 1].to >= t) {
+			let o = new A(a.tree, a.overlay[0].from + e.from, -1, e);
+			(i ||= [r]).push(k(o, t, n, !1));
+		}
+	}
+	return i ? ce(i) : r;
+}
+var M = class {
+	get name() {
+		return this.type.name;
+	}
+	constructor(e, t = 0) {
+		if (this.buffer = null, this.stack = [], this.index = 0, this.bufferNode = null, this.mode = t & ~E.EnterBracketed, e instanceof A) this.yieldNode(e);
+		else {
+			this._tree = e.context.parent, this.buffer = e.context;
+			for (let t = e._parent; t; t = t._parent) this.stack.unshift(t.index);
+			this.bufferNode = e, this.yieldBuf(e.index);
+		}
+	}
+	yieldNode(e) {
+		return e ? (this._tree = e, this.type = e.type, this.from = e.from, this.to = e.to, !0) : !1;
+	}
+	yieldBuf(e, t) {
+		this.index = e;
+		let { start: n, buffer: r } = this.buffer;
+		return this.type = t || r.set.types[r.buffer[e]], this.from = n + r.buffer[e + 1], this.to = n + r.buffer[e + 2], !0;
+	}
+	yield(e) {
+		return e ? e instanceof A ? (this.buffer = null, this.yieldNode(e)) : (this.buffer = e.context, this.yieldBuf(e.index, e.type)) : !1;
+	}
+	toString() {
+		return this.buffer ? this.buffer.buffer.childString(this.index) : this._tree.toString();
+	}
+	enterChild(e, t, n) {
+		if (!this.buffer) return this.yield(this._tree.nextChild(e < 0 ? this._tree._tree.children.length - 1 : 0, e, t, n, this.mode));
+		let { buffer: r } = this.buffer, i = r.findChild(this.index + 4, r.buffer[this.index + 3], e, t - this.buffer.start, n);
+		return i < 0 ? !1 : (this.stack.push(this.index), this.yieldBuf(i));
+	}
+	firstChild() {
+		return this.enterChild(1, 0, 4);
+	}
+	lastChild() {
+		return this.enterChild(-1, 0, 4);
+	}
+	childAfter(e) {
+		return this.enterChild(1, e, 2);
+	}
+	childBefore(e) {
+		return this.enterChild(-1, e, -2);
+	}
+	enter(e, t, n = this.mode) {
+		return this.buffer ? n & E.ExcludeBuffers ? !1 : this.enterChild(1, e, t) : this.yield(this._tree.enter(e, t, n));
+	}
+	parent() {
+		if (!this.buffer) return this.yieldNode(this.mode & E.IncludeAnonymous ? this._tree._parent : this._tree.parent);
+		if (this.stack.length) return this.yieldBuf(this.stack.pop());
+		let e = this.mode & E.IncludeAnonymous ? this.buffer.parent : this.buffer.parent.nextSignificantParent();
+		return this.buffer = null, this.yieldNode(e);
+	}
+	sibling(e) {
+		if (!this.buffer) return this._tree._parent ? this.yield(this._tree.index < 0 ? null : this._tree._parent.nextChild(this._tree.index + e, e, 0, 4, this.mode)) : !1;
+		let { buffer: t } = this.buffer, n = this.stack.length - 1;
+		if (e < 0) {
+			let e = n < 0 ? 0 : this.stack[n] + 4;
+			if (this.index != e) return this.yieldBuf(t.findChild(e, this.index, -1, 0, 4));
+		} else {
+			let e = t.buffer[this.index + 3];
+			if (e < (n < 0 ? t.buffer.length : t.buffer[this.stack[n] + 3])) return this.yieldBuf(e);
+		}
+		return n < 0 && this.yield(this.buffer.parent.nextChild(this.buffer.index + e, e, 0, 4, this.mode));
+	}
+	nextSibling() {
+		return this.sibling(1);
+	}
+	prevSibling() {
+		return this.sibling(-1);
+	}
+	atLastNode(e) {
+		let t, n, { buffer: r } = this;
+		if (r) {
+			if (e > 0) {
+				if (this.index < r.buffer.buffer.length) return !1;
+			} else for (let e = 0; e < this.index; e++) if (r.buffer.buffer[e + 3] < this.index) return !1;
+			({index: t, parent: n} = r);
+		} else ({index: t, _parent: n} = this._tree);
+		for (; n; {index: t, _parent: n} = n) if (t > -1) for (let r = t + e, i = e < 0 ? -1 : n._tree.children.length; r != i; r += e) {
+			let e = n._tree.children[r];
+			if (this.mode & E.IncludeAnonymous || e instanceof O || !e.type.isAnonymous || de(e)) return !1;
+		}
+		return !0;
+	}
+	move(e, t) {
+		if (t && this.enterChild(e, 0, 4)) return !0;
+		for (;;) {
+			if (this.sibling(e)) return !0;
+			if (this.atLastNode(e) || !this.parent()) return !1;
+		}
+	}
+	next(e = !0) {
+		return this.move(1, e);
+	}
+	prev(e = !0) {
+		return this.move(-1, e);
+	}
+	moveTo(e, t = 0) {
+		for (; (this.from == this.to || (t < 1 ? this.from >= e : this.from > e) || (t > -1 ? this.to <= e : this.to < e)) && this.parent(););
+		for (; this.enterChild(1, e, t););
+		return this;
+	}
+	get node() {
+		if (!this.buffer) return this._tree;
+		let e = this.bufferNode, t = null, n = 0;
+		if (e && e.context == this.buffer) scan: for (let r = this.index, i = this.stack.length; i >= 0;) {
+			for (let a = e; a; a = a._parent) if (a.index == r) {
+				if (r == this.index) return a;
+				t = a, n = i + 1;
+				break scan;
+			}
+			r = this.stack[--i];
+		}
+		for (let e = n; e < this.stack.length; e++) t = new j(this.buffer, t, this.stack[e]);
+		return this.bufferNode = new j(this.buffer, t, this.index);
+	}
+	get tree() {
+		return this.buffer ? null : this._tree._tree;
+	}
+	iterate(e, t) {
+		for (let n = 0;;) {
+			let r = !1;
+			if (this.type.isAnonymous || e(this) !== !1) {
+				if (this.firstChild()) {
+					n++;
+					continue;
+				}
+				this.type.isAnonymous || (r = !0);
+			}
+			for (;;) {
+				if (r && t && t(this), r = this.type.isAnonymous, !n) return;
+				if (this.nextSibling()) break;
+				this.parent(), n--, r = !0;
+			}
+		}
+	}
+	matchContext(e) {
+		if (!this.buffer) return oe(this.node.parent, e);
+		let { buffer: t } = this.buffer, { types: n } = t.set;
+		for (let r = e.length - 1, i = this.stack.length - 1; r >= 0; i--) {
+			if (i < 0) return oe(this._tree, e, r);
+			let a = n[t.buffer[this.stack[i]]];
+			if (!a.isAnonymous) {
+				if (e[r] && e[r] != a.name) return !1;
+				r--;
+			}
+		}
+		return !0;
+	}
+};
+function de(e) {
+	return e.children.some((e) => e instanceof O || !e.type.isAnonymous || de(e));
+}
+function fe(e) {
+	let { buffer: t, nodeSet: n, maxBufferLength: r = ee, reused: i = [], minRepeatType: a = n.types.length } = e, o = Array.isArray(t) ? new ne(t, t.length) : t, s = n.types, c = 0, l = 0;
+	function u(e, t, _, ee, v, y) {
+		let { id: b, start: x, end: S, size: C } = o, te = l, w = c;
+		if (C < 0) {
+			if (o.next(), C == -1) {
+				let t = i[b];
+				_.push(t), ee.push(x - e);
+				return;
+			}
+			if (C == -3) {
+				c = b;
+				return;
+			}
+			if (C == -4) {
+				l = b;
+				return;
+			}
+			throw RangeError(`Unrecognized record size: ${C}`);
+		}
+		let T = s[b], E, D, ne = x - e;
+		if (S - x <= r && (D = h(o.pos - t, v))) {
+			let t = new Uint16Array(D.size - D.skip), r = o.pos - D.size, i = t.length;
+			for (; o.pos > r;) i = g(D.start, t, i);
+			E = new O(t, S - D.start, n), ne = D.start - e;
+		} else {
+			let e = o.pos - C;
+			o.next();
+			let t = [], n = [], i = b >= a ? b : -1, s = 0, c = S;
+			for (; o.pos > e;) i >= 0 && o.id == i && o.size >= 0 ? (o.end <= c - r && (p(t, n, x, s, o.end, c, i, te, w), s = t.length, c = o.end), o.next()) : y > 2500 ? d(x, e, t, n) : u(x, e, t, n, i, y + 1);
+			if (i >= 0 && s > 0 && s < t.length && p(t, n, x, s, x, c, i, te, w), t.reverse(), n.reverse(), i > -1 && s > 0) {
+				let e = f(T, w);
+				E = he(T, t, n, 0, t.length, 0, S - x, e, e);
+			} else E = m(T, t, n, S - x, te - S, w);
+		}
+		_.push(E), ee.push(ne);
+	}
+	function d(e, t, i, a) {
+		let s = [], c = 0, l = -1;
+		for (; o.pos > t;) {
+			let { id: e, start: t, end: n, size: i } = o;
+			if (i > 4) o.next();
+			else if (l > -1 && t < l) break;
+			else l < 0 && (l = n - r), s.push(e, t, n), c++, o.next();
+		}
+		if (c) {
+			let t = new Uint16Array(c * 4), r = s[s.length - 2];
+			for (let e = s.length - 3, n = 0; e >= 0; e -= 3) t[n++] = s[e], t[n++] = s[e + 1] - r, t[n++] = s[e + 2] - r, t[n++] = n;
+			i.push(new O(t, s[2] - r, n)), a.push(r - e);
+		}
+	}
+	function f(e, t) {
+		return (n, r, i) => {
+			let a = 0, o = n.length - 1, s, c;
+			if (o >= 0 && (s = n[o]) instanceof D) {
+				if (!o && s.type == e && s.length == i) return s;
+				(c = s.prop(b.lookAhead)) && (a = r[o] + s.length + c);
+			}
+			return m(e, n, r, i, a, t);
+		};
+	}
+	function p(e, t, r, i, a, o, s, c, l) {
+		let u = [], d = [];
+		for (; e.length > i;) u.push(e.pop()), d.push(t.pop() + r - a);
+		e.push(m(n.types[s], u, d, o - a, c - o, l)), t.push(a - r);
+	}
+	function m(e, t, n, r, i, a, o) {
+		if (a) {
+			let e = [b.contextHash, a];
+			o = o ? [e].concat(o) : [e];
+		}
+		if (i > 25) {
+			let e = [b.lookAhead, i];
+			o = o ? [e].concat(o) : [e];
+		}
+		return new D(e, t, n, r, o);
+	}
+	function h(e, t) {
+		let n = o.fork(), i = 0, s = 0, c = 0, l = n.end - r, u = {
+			size: 0,
+			start: 0,
+			skip: 0
+		};
+		scan: for (let r = n.pos - e; n.pos > r;) {
+			let e = n.size;
+			if (n.id == t && e >= 0) {
+				u.size = i, u.start = s, u.skip = c, c += 4, i += 4, n.next();
+				continue;
+			}
+			let o = n.pos - e;
+			if (e < 0 || o < r || n.start < l) break;
+			let d = n.id >= a ? 4 : 0, f = n.start;
+			for (n.next(); n.pos > o;) {
+				if (n.size < 0) {
+					if (n.size == -3 || n.size == -4) d += 4;
+					else break scan;
+				} else n.id >= a && (d += 4);
+				n.next();
+			}
+			s = f, i += e, c += d;
+		}
+		return (t < 0 || i == e) && (u.size = i, u.start = s, u.skip = c), u.size > 4 ? u : void 0;
+	}
+	function g(e, t, n) {
+		let { id: r, start: i, end: s, size: u } = o;
+		if (o.next(), u >= 0 && r < a) {
+			let a = n;
+			if (u > 4) {
+				let r = o.pos - (u - 4);
+				for (; o.pos > r;) n = g(e, t, n);
+			}
+			t[--n] = a, t[--n] = s - e, t[--n] = i - e, t[--n] = r;
+		} else u == -3 ? c = r : u == -4 && (l = r);
+		return n;
+	}
+	let _ = [], v = [];
+	for (; o.pos > 0;) u(e.start || 0, e.bufferStart || 0, _, v, -1, 0);
+	let y = e.length ?? (_.length ? v[0] + _[0].length : 0);
+	return new D(s[e.topID], _.reverse(), v.reverse(), y);
+}
+var pe = /* @__PURE__ */ new WeakMap();
+function me(e, t) {
+	if (!e.isAnonymous || t instanceof O || t.type != e) return 1;
+	let n = pe.get(t);
+	if (n == null) {
+		n = 1;
+		for (let r of t.children) {
+			if (r.type != e || !(r instanceof D)) {
+				n = 1;
+				break;
+			}
+			n += me(e, r);
+		}
+		pe.set(t, n);
+	}
+	return n;
+}
+function he(e, t, n, r, i, a, o, s, c) {
+	let l = 0;
+	for (let n = r; n < i; n++) l += me(e, t[n]);
+	let u = Math.ceil(l * 1.5 / 8), d = [], f = [];
+	function p(t, n, r, i, o) {
+		for (let s = r; s < i;) {
+			let r = s, l = n[s], m = me(e, t[s]);
+			for (s++; s < i; s++) {
+				let n = me(e, t[s]);
+				if (m + n >= u) break;
+				m += n;
+			}
+			if (s == r + 1) {
+				if (m > u) {
+					let e = t[r];
+					p(e.children, e.positions, 0, e.children.length, n[r] + o);
+					continue;
+				}
+				d.push(t[r]);
+			} else {
+				let i = n[s - 1] + t[s - 1].length - l;
+				d.push(he(e, t, n, r, s, l, i, null, c));
+			}
+			f.push(l + o - a);
+		}
+	}
+	return p(t, n, r, i, 0), (s || c)(d, f, o);
+}
+var ge = class {
+	constructor() {
+		this.map = /* @__PURE__ */ new WeakMap();
+	}
+	setBuffer(e, t, n) {
+		let r = this.map.get(e);
+		r || this.map.set(e, r = /* @__PURE__ */ new Map()), r.set(t, n);
+	}
+	getBuffer(e, t) {
+		let n = this.map.get(e);
+		return n && n.get(t);
+	}
+	set(e, t) {
+		e instanceof j ? this.setBuffer(e.context.buffer, e.index, t) : e instanceof A && this.map.set(e.tree, t);
+	}
+	get(e) {
+		return e instanceof j ? this.getBuffer(e.context.buffer, e.index) : e instanceof A ? this.map.get(e.tree) : void 0;
+	}
+	cursorSet(e, t) {
+		e.buffer ? this.setBuffer(e.buffer.buffer, e.index, t) : this.map.set(e.tree, t);
+	}
+	cursorGet(e) {
+		return e.buffer ? this.getBuffer(e.buffer.buffer, e.index) : this.map.get(e.tree);
+	}
+}, N = class e {
+	constructor(e, t, n, r, i = !1, a = !1) {
+		this.from = e, this.to = t, this.tree = n, this.offset = r, this.open = !!i | (a ? 2 : 0);
+	}
+	get openStart() {
+		return (this.open & 1) > 0;
+	}
+	get openEnd() {
+		return (this.open & 2) > 0;
+	}
+	static addTree(t, n = [], r = !1) {
+		let i = [new e(0, t.length, t, 0, !1, r)];
+		for (let e of n) e.to > t.length && i.push(e);
+		return i;
+	}
+	static applyChanges(t, n, r = 128) {
+		if (!n.length) return t;
+		let i = [], a = 1, o = t.length ? t[0] : null;
+		for (let s = 0, c = 0, l = 0;; s++) {
+			let u = s < n.length ? n[s] : null, d = u ? u.fromA : 1e9;
+			if (d - c >= r) for (; o && o.from < d;) {
+				let n = o;
+				if (c >= n.from || d <= n.to || l) {
+					let t = Math.max(n.from, c) - l, r = Math.min(n.to, d) - l;
+					n = t >= r ? null : new e(t, r, n.tree, n.offset + l, s > 0, !!u);
+				}
+				if (n && i.push(n), o.to > d) break;
+				o = a < t.length ? t[a++] : null;
+			}
+			if (!u) break;
+			c = u.toA, l = u.toA - u.toB;
+		}
+		return i;
+	}
+}, _e = class {
+	startParse(e, t, n) {
+		return typeof e == "string" && (e = new ve(e)), n = n ? n.length ? n.map((e) => new y(e.from, e.to)) : [new y(0, 0)] : [new y(0, e.length)], this.createParse(e, t || [], n);
+	}
+	parse(e, t, n) {
+		let r = this.startParse(e, t, n);
+		for (;;) {
+			let e = r.advance();
+			if (e) return e;
+		}
+	}
+}, ve = class {
+	constructor(e) {
+		this.string = e;
+	}
+	get length() {
+		return this.string.length;
+	}
+	chunk(e) {
+		return this.string.slice(e);
+	}
+	get lineChunks() {
+		return !1;
+	}
+	read(e, t) {
+		return this.string.slice(e, t);
+	}
+};
+function ye(e) {
+	return (t, n, r, i) => new we(t, e, n, r, i);
+}
+var be = class {
+	constructor(e, t, n, r, i, a) {
+		this.parser = e, this.parse = t, this.overlay = n, this.bracketed = r, this.target = i, this.from = a;
+	}
+};
+function xe(e) {
+	if (!e.length || e.some((e) => e.from >= e.to)) throw RangeError("Invalid inner parse ranges given: " + JSON.stringify(e));
+}
+var Se = class {
+	constructor(e, t, n, r, i, a, o, s) {
+		this.parser = e, this.predicate = t, this.mounts = n, this.index = r, this.start = i, this.bracketed = a, this.target = o, this.prev = s, this.depth = 0, this.ranges = [];
+	}
+}, Ce = new b({ perNode: !0 }), we = class {
+	constructor(e, t, n, r, i) {
+		this.nest = t, this.input = n, this.fragments = r, this.ranges = i, this.inner = [], this.innerDone = 0, this.baseTree = null, this.stoppedAt = null, this.baseParse = e;
+	}
+	advance() {
+		if (this.baseParse) {
+			let e = this.baseParse.advance();
+			if (!e) return null;
+			if (this.baseParse = null, this.baseTree = e, this.startInner(), this.stoppedAt != null) for (let e of this.inner) e.parse.stopAt(this.stoppedAt);
+		}
+		if (this.innerDone == this.inner.length) {
+			let e = this.baseTree;
+			return this.stoppedAt != null && (e = new D(e.type, e.children, e.positions, e.length, e.propValues.concat([[Ce, this.stoppedAt]]))), e;
+		}
+		let e = this.inner[this.innerDone], t = e.parse.advance();
+		if (t) {
+			this.innerDone++;
+			let n = Object.assign(Object.create(null), e.target.props);
+			n[b.mounted.id] = new x(t, e.overlay, e.parser, e.bracketed), e.target.props = n;
+		}
+		return null;
+	}
+	get parsedPos() {
+		if (this.baseParse) return 0;
+		let e = this.input.length;
+		for (let t = this.innerDone; t < this.inner.length; t++) this.inner[t].from < e && (e = Math.min(e, this.inner[t].parse.parsedPos));
+		return e;
+	}
+	stopAt(e) {
+		if (this.stoppedAt = e, this.baseParse) this.baseParse.stopAt(e);
+		else for (let t = this.innerDone; t < this.inner.length; t++) this.inner[t].parse.stopAt(e);
+	}
+	startInner() {
+		let e = new ke(this.fragments), t = null, n = null, r = new M(new A(this.baseTree, this.ranges[0].from, 0, null), E.IncludeAnonymous | E.IgnoreMounts);
+		scan: for (let i, a;;) {
+			let o = !0, s;
+			if (this.stoppedAt != null && r.from >= this.stoppedAt) o = !1;
+			else if (e.hasNode(r)) {
+				if (t) {
+					let e = t.mounts.find((e) => e.frag.from <= r.from && e.frag.to >= r.to && e.mount.overlay);
+					if (e) for (let n of e.mount.overlay) {
+						let i = n.from + e.pos, a = n.to + e.pos;
+						i >= r.from && a <= r.to && !t.ranges.some((e) => e.from < a && e.to > i) && t.ranges.push({
+							from: i,
+							to: a
+						});
+					}
+				}
+				o = !1;
+			} else if (n && (a = Te(n.ranges, r.from, r.to))) o = a != 2;
+			else if (!r.type.isAnonymous && (i = this.nest(r, this.input)) && (r.from < r.to || !i.overlay)) {
+				r.tree || (De(r), t && t.depth++, n && n.depth++);
+				let a = e.findMounts(r.from, i.parser);
+				if (typeof i.overlay == "function") t = new Se(i.parser, i.overlay, a, this.inner.length, r.from, !!i.bracketed, r.tree, t);
+				else {
+					let e = Ae(this.ranges, i.overlay || (r.from < r.to ? [new y(r.from, r.to)] : []));
+					e.length && xe(e), (e.length || !i.overlay) && this.inner.push(new be(i.parser, e.length ? i.parser.startParse(this.input, Me(a, e), e) : i.parser.startParse(""), i.overlay ? i.overlay.map((e) => new y(e.from - r.from, e.to - r.from)) : null, !!i.bracketed, r.tree, e.length ? e[0].from : r.from)), i.overlay ? e.length && (n = {
+						ranges: e,
+						depth: 0,
+						prev: n
+					}) : o = !1;
+				}
+			} else if (t && (s = t.predicate(r)) && (s === !0 && (s = new y(r.from, r.to)), s.from < s.to)) {
+				let e = t.ranges.length - 1;
+				e >= 0 && t.ranges[e].to == s.from ? t.ranges[e] = {
+					from: t.ranges[e].from,
+					to: s.to
+				} : t.ranges.push(s);
+			}
+			if (o && r.firstChild()) t && t.depth++, n && n.depth++;
+			else for (; !r.nextSibling();) {
+				if (!r.parent()) break scan;
+				if (t && !--t.depth) {
+					let e = Ae(this.ranges, t.ranges);
+					e.length && (xe(e), this.inner.splice(t.index, 0, new be(t.parser, t.parser.startParse(this.input, Me(t.mounts, e), e), t.ranges.map((e) => new y(e.from - t.start, e.to - t.start)), t.bracketed, t.target, e[0].from))), t = t.prev;
+				}
+				n && !--n.depth && (n = n.prev);
+			}
+		}
+	}
+};
+function Te(e, t, n) {
+	for (let r of e) {
+		if (r.from >= n) break;
+		if (r.to > t) return r.from <= t && r.to >= n ? 2 : 1;
+	}
+	return 0;
+}
+function Ee(e, t, n, r, i, a) {
+	if (t < n) {
+		let o = e.buffer[t + 1];
+		r.push(e.slice(t, n, o)), i.push(o - a);
+	}
+}
+function De(e) {
+	let { node: t } = e, n = [], r = t.context.buffer;
+	do
+		n.push(e.index), e.parent();
+	while (!e.tree);
+	let i = e.tree, a = i.children.indexOf(r), o = i.children[a], s = o.buffer, c = [a];
+	function l(e, r, i, a, u, d) {
+		let f = n[d], p = [], m = [];
+		Ee(o, e, f, p, m, a);
+		let h = s[f + 1], g = s[f + 2];
+		c.push(p.length);
+		let _ = d ? l(f + 4, s[f + 3], o.set.types[s[f]], h, g - h, d - 1) : t.toTree();
+		return p.push(_), m.push(h - a), Ee(o, s[f + 3], r, p, m, a), new D(i, p, m, u);
+	}
+	i.children[a] = l(0, s.length, C.none, 0, o.length, n.length - 1);
+	for (let t of c) {
+		let n = e.tree.children[t], r = e.tree.positions[t];
+		e.yield(new A(n, r + e.from, t, e._tree));
+	}
+}
+var Oe = class {
+	constructor(e, t) {
+		this.offset = t, this.done = !1, this.cursor = e.cursor(E.IncludeAnonymous | E.IgnoreMounts);
+	}
+	moveTo(e) {
+		let { cursor: t } = this, n = e - this.offset;
+		for (; !this.done && t.from < n;) if (!(t.to >= e && t.enter(n, 1, E.IgnoreOverlays | E.ExcludeBuffers))) {
+			if (t.to <= e) t.next(!1) || (this.done = !0);
+			else break;
+		}
+	}
+	hasNode(e) {
+		if (this.moveTo(e.from), !this.done && this.cursor.from + this.offset == e.from && this.cursor.tree) for (let t = this.cursor.tree;;) {
+			if (t == e.tree) return !0;
+			if (t.children.length && t.positions[0] == 0 && t.children[0] instanceof D) t = t.children[0];
+			else break;
+		}
+		return !1;
+	}
+}, ke = class {
+	constructor(e) {
+		if (this.fragments = e, this.curTo = 0, this.fragI = 0, e.length) {
+			let t = this.curFrag = e[0];
+			this.curTo = t.tree.prop(Ce) ?? t.to, this.inner = new Oe(t.tree, -t.offset);
+		} else this.curFrag = this.inner = null;
+	}
+	hasNode(e) {
+		for (; this.curFrag && e.from >= this.curTo;) this.nextFrag();
+		return this.curFrag && this.curFrag.from <= e.from && this.curTo >= e.to && this.inner.hasNode(e);
+	}
+	nextFrag() {
+		if (this.fragI++, this.fragI == this.fragments.length) this.curFrag = this.inner = null;
+		else {
+			let e = this.curFrag = this.fragments[this.fragI];
+			this.curTo = e.tree.prop(Ce) ?? e.to, this.inner = new Oe(e.tree, -e.offset);
+		}
+	}
+	findMounts(e, t) {
+		let n = [];
+		if (this.inner) {
+			this.inner.cursor.moveTo(e, 1);
+			for (let e = this.inner.cursor.node; e; e = e.parent) {
+				let r = e.tree?.prop(b.mounted);
+				if (r && r.parser == t) for (let t = this.fragI; t < this.fragments.length; t++) {
+					let i = this.fragments[t];
+					if (i.from >= e.to) break;
+					i.tree == this.curFrag.tree && n.push({
+						frag: i,
+						pos: e.from - i.offset,
+						mount: r
+					});
+				}
+			}
+		}
+		return n;
+	}
+};
+function Ae(e, t) {
+	let n = null, r = t;
+	for (let i = 1, a = 0; i < e.length; i++) {
+		let o = e[i - 1].to, s = e[i].from;
+		for (; a < r.length; a++) {
+			let e = r[a];
+			if (e.from >= s) break;
+			e.to <= o || (n || (r = n = t.slice()), e.from < o ? (n[a] = new y(e.from, o), e.to > s && n.splice(a + 1, 0, new y(s, e.to))) : e.to > s ? n[a--] = new y(s, e.to) : n.splice(a--, 1));
+		}
+	}
+	return r;
+}
+function je(e, t, n, r) {
+	let i = 0, a = 0, o = !1, s = !1, c = -1e9, l = [];
+	for (;;) {
+		let u = i == e.length ? 1e9 : o ? e[i].to : e[i].from, d = a == t.length ? 1e9 : s ? t[a].to : t[a].from;
+		if (o != s) {
+			let e = Math.max(c, n), t = Math.min(u, d, r);
+			e < t && l.push(new y(e, t));
+		}
+		if (c = Math.min(u, d), c == 1e9) break;
+		u == c && (o ? (o = !1, i++) : o = !0), d == c && (s ? (s = !1, a++) : s = !0);
+	}
+	return l;
+}
+function Me(e, t) {
+	let n = [];
+	for (let { pos: r, mount: i, frag: a } of e) {
+		let e = r + (i.overlay ? i.overlay[0].from : 0), o = e + i.tree.length, s = Math.max(a.from, e), c = Math.min(a.to, o);
+		if (i.overlay) {
+			let o = je(t, i.overlay.map((e) => new y(e.from + r, e.to + r)), s, c);
+			for (let t = 0, r = s;; t++) {
+				let s = t == o.length, l = s ? c : o[t].from;
+				if (l > r && n.push(new N(r, l, i.tree, -e, a.from >= r || a.openStart, a.to <= l || a.openEnd)), s) break;
+				r = o[t].to;
+			}
+		} else n.push(new N(s, c, i.tree, -e, a.from >= e || a.openStart, a.to <= o || a.openEnd));
+	}
+	return n;
+}
+//#endregion
+//#region ../../node_modules/.bun/@lezer+highlight@1.2.3/node_modules/@lezer/highlight/dist/index.js
+var Ne = 0, P = class e {
+	constructor(e, t, n, r) {
+		this.name = e, this.set = t, this.base = n, this.modified = r, this.id = Ne++;
+	}
+	toString() {
+		let { name: e } = this;
+		for (let t of this.modified) t.name && (e = `${t.name}(${e})`);
+		return e;
+	}
+	static define(t, n) {
+		let r = typeof t == "string" ? t : "?";
+		if (t instanceof e && (n = t), n?.base) throw Error("Can not derive from a modified tag");
+		let i = new e(r, [], null, []);
+		if (i.set.push(i), n) for (let e of n.set) i.set.push(e);
+		return i;
+	}
+	static defineModifier(e) {
+		let t = new Fe(e);
+		return (e) => e.modified.indexOf(t) > -1 ? e : Fe.get(e.base || e, e.modified.concat(t).sort((e, t) => e.id - t.id));
+	}
+}, Pe = 0, Fe = class e {
+	constructor(e) {
+		this.name = e, this.instances = [], this.id = Pe++;
+	}
+	static get(t, n) {
+		if (!n.length) return t;
+		let r = n[0].instances.find((e) => e.base == t && Ie(n, e.modified));
+		if (r) return r;
+		let i = [], a = new P(t.name, i, t, n);
+		for (let e of n) e.instances.push(a);
+		let o = Le(n);
+		for (let n of t.set) if (!n.modified.length) for (let t of o) i.push(e.get(n, t));
+		return a;
+	}
+};
+function Ie(e, t) {
+	return e.length == t.length && e.every((e, n) => e == t[n]);
+}
+function Le(e) {
+	let t = [[]];
+	for (let n = 0; n < e.length; n++) for (let r = 0, i = t.length; r < i; r++) t.push(t[r].concat(e[n]));
+	return t.sort((e, t) => t.length - e.length);
+}
+function Re(e) {
+	let t = Object.create(null);
+	for (let n in e) {
+		let r = e[n];
+		Array.isArray(r) || (r = [r]);
+		for (let e of n.split(" ")) if (e) {
+			let n = [], i = 2, a = e;
+			for (let t = 0;;) {
+				if (a == "..." && t > 0 && t + 3 == e.length) {
+					i = 1;
+					break;
+				}
+				let r = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(a);
+				if (!r) throw RangeError("Invalid path: " + e);
+				if (n.push(r[0] == "*" ? "" : r[0][0] == "\"" ? JSON.parse(r[0]) : r[0]), t += r[0].length, t == e.length) break;
+				let o = e[t++];
+				if (t == e.length && o == "!") {
+					i = 0;
+					break;
+				}
+				if (o != "/") throw RangeError("Invalid path: " + e);
+				a = e.slice(t);
+			}
+			let o = n.length - 1, s = n[o];
+			if (!s) throw RangeError("Invalid path: " + e);
+			t[s] = new F(r, i, o > 0 ? n.slice(0, o) : null).sort(t[s]);
+		}
+	}
+	return ze.add(t);
+}
+var ze = new b({ combine(e, t) {
+	let n, r, i;
+	for (; e || t;) {
+		if (!e || t && e.depth >= t.depth ? (i = t, t = t.next) : (i = e, e = e.next), n && n.mode == i.mode && !i.context && !n.context) continue;
+		let a = new F(i.tags, i.mode, i.context);
+		n ? n.next = a : r = a, n = a;
+	}
+	return r;
+} }), F = class {
+	constructor(e, t, n, r) {
+		this.tags = e, this.mode = t, this.context = n, this.next = r;
+	}
+	get opaque() {
+		return this.mode == 0;
+	}
+	get inherit() {
+		return this.mode == 1;
+	}
+	sort(e) {
+		return !e || e.depth < this.depth ? (this.next = e, this) : (e.next = this.sort(e.next), e);
+	}
+	get depth() {
+		return this.context ? this.context.length : 0;
+	}
+};
+F.empty = new F([], 2, null);
+function Be(e, t) {
+	let n = Object.create(null);
+	for (let t of e) if (!Array.isArray(t.tag)) n[t.tag.id] = t.class;
+	else for (let e of t.tag) n[e.id] = t.class;
+	let { scope: r, all: i = null } = t || {};
+	return {
+		style: (e) => {
+			let t = i;
+			for (let r of e) for (let e of r.set) {
+				let r = n[e.id];
+				if (r) {
+					t = t ? t + " " + r : r;
+					break;
+				}
+			}
+			return t;
+		},
+		scope: r
+	};
+}
+function Ve(e, t) {
+	let n = null;
+	for (let r of e) {
+		let e = r.style(t);
+		e && (n = n ? n + " " + e : e);
+	}
+	return n;
+}
+function He(e, t, n, r = 0, i = e.length) {
+	let a = new We(r, Array.isArray(t) ? t : [t], n);
+	a.highlightRange(e.cursor(), r, i, "", a.highlighters), a.flush(i);
+}
+function Ue(e, t, n, r, i, a = 0, o = e.length) {
+	let s = a;
+	function c(t, n) {
+		if (!(t <= s)) {
+			for (let a = e.slice(s, t), o = 0;;) {
+				let e = a.indexOf("\n", o), t = e < 0 ? a.length : e;
+				if (t > o && r(a.slice(o, t), n), e < 0) break;
+				i(), o = e + 1;
+			}
+			s = t;
+		}
+	}
+	He(t, n, (e, t, n) => {
+		c(e, ""), c(t, n);
+	}, a, o), c(o, "");
+}
+var We = class {
+	constructor(e, t, n) {
+		this.at = e, this.highlighters = t, this.span = n, this.class = "";
+	}
+	startSpan(e, t) {
+		t != this.class && (this.flush(e), e > this.at && (this.at = e), this.class = t);
+	}
+	flush(e) {
+		e > this.at && this.class && this.span(this.at, e, this.class);
+	}
+	highlightRange(e, t, n, r, i) {
+		let { type: a, from: o, to: s } = e;
+		if (o >= n || s <= t) return;
+		a.isTop && (i = this.highlighters.filter((e) => !e.scope || e.scope(a)));
+		let c = r, l = Ge(e) || F.empty, u = Ve(i, l.tags);
+		if (u && (c && (c += " "), c += u, l.mode == 1 && (r += (r ? " " : "") + u)), this.startSpan(Math.max(t, o), c), l.opaque) return;
+		let d = e.tree && e.tree.prop(b.mounted);
+		if (d && d.overlay) {
+			let a = e.node.enter(d.overlay[0].from + o, 1), l = this.highlighters.filter((e) => !e.scope || e.scope(d.tree.type)), u = e.firstChild();
+			for (let f = 0, p = o;; f++) {
+				let m = f < d.overlay.length ? d.overlay[f] : null, h = m ? m.from + o : s, g = Math.max(t, p), _ = Math.min(n, h);
+				if (g < _ && u) for (; e.from < _ && (this.highlightRange(e, g, _, r, i), this.startSpan(Math.min(_, e.to), c), !(e.to >= h || !e.nextSibling())););
+				if (!m || h > n) break;
+				p = m.to + o, p > t && (this.highlightRange(a.cursor(), Math.max(t, m.from + o), Math.min(n, p), "", l), this.startSpan(Math.min(n, p), c));
+			}
+			u && e.parent();
+		} else if (e.firstChild()) {
+			d && (r = "");
+			do
+				if (!(e.to <= t)) {
+					if (e.from >= n) break;
+					this.highlightRange(e, t, n, r, i), this.startSpan(Math.min(n, e.to), c);
+				}
+			while (e.nextSibling());
+			e.parent();
+		}
+	}
+};
+function Ge(e) {
+	let t = e.type.prop(ze);
+	for (; t && t.context && !e.matchContext(t.context);) t = t.next;
+	return t || null;
+}
+var I = P.define, L = I(), R = I(), Ke = I(R), qe = I(R), z = I(), Je = I(z), Ye = I(z), B = I(), V = I(B), H = I(), U = I(), Xe = I(), W = I(Xe), Ze = I(), G = {
+	comment: L,
+	lineComment: I(L),
+	blockComment: I(L),
+	docComment: I(L),
+	name: R,
+	variableName: I(R),
+	typeName: Ke,
+	tagName: I(Ke),
+	propertyName: qe,
+	attributeName: I(qe),
+	className: I(R),
+	labelName: I(R),
+	namespace: I(R),
+	macroName: I(R),
+	literal: z,
+	string: Je,
+	docString: I(Je),
+	character: I(Je),
+	attributeValue: I(Je),
+	number: Ye,
+	integer: I(Ye),
+	float: I(Ye),
+	bool: I(z),
+	regexp: I(z),
+	escape: I(z),
+	color: I(z),
+	url: I(z),
+	keyword: H,
+	self: I(H),
+	null: I(H),
+	atom: I(H),
+	unit: I(H),
+	modifier: I(H),
+	operatorKeyword: I(H),
+	controlKeyword: I(H),
+	definitionKeyword: I(H),
+	moduleKeyword: I(H),
+	operator: U,
+	derefOperator: I(U),
+	arithmeticOperator: I(U),
+	logicOperator: I(U),
+	bitwiseOperator: I(U),
+	compareOperator: I(U),
+	updateOperator: I(U),
+	definitionOperator: I(U),
+	typeOperator: I(U),
+	controlOperator: I(U),
+	punctuation: Xe,
+	separator: I(Xe),
+	bracket: W,
+	angleBracket: I(W),
+	squareBracket: I(W),
+	paren: I(W),
+	brace: I(W),
+	content: B,
+	heading: V,
+	heading1: I(V),
+	heading2: I(V),
+	heading3: I(V),
+	heading4: I(V),
+	heading5: I(V),
+	heading6: I(V),
+	contentSeparator: I(B),
+	list: I(B),
+	quote: I(B),
+	emphasis: I(B),
+	strong: I(B),
+	link: I(B),
+	monospace: I(B),
+	strikethrough: I(B),
+	inserted: I(),
+	deleted: I(),
+	changed: I(),
+	invalid: I(),
+	meta: Ze,
+	documentMeta: I(Ze),
+	annotation: I(Ze),
+	processingInstruction: I(Ze),
+	definition: P.defineModifier("definition"),
+	constant: P.defineModifier("constant"),
+	function: P.defineModifier("function"),
+	standard: P.defineModifier("standard"),
+	local: P.defineModifier("local"),
+	special: P.defineModifier("special")
+};
+for (let e in G) {
+	let t = G[e];
+	t instanceof P && (t.name = e);
+}
+Be([
+	{
+		tag: G.link,
+		class: "tok-link"
+	},
+	{
+		tag: G.heading,
+		class: "tok-heading"
+	},
+	{
+		tag: G.emphasis,
+		class: "tok-emphasis"
+	},
+	{
+		tag: G.strong,
+		class: "tok-strong"
+	},
+	{
+		tag: G.keyword,
+		class: "tok-keyword"
+	},
+	{
+		tag: G.atom,
+		class: "tok-atom"
+	},
+	{
+		tag: G.bool,
+		class: "tok-bool"
+	},
+	{
+		tag: G.url,
+		class: "tok-url"
+	},
+	{
+		tag: G.labelName,
+		class: "tok-labelName"
+	},
+	{
+		tag: G.inserted,
+		class: "tok-inserted"
+	},
+	{
+		tag: G.deleted,
+		class: "tok-deleted"
+	},
+	{
+		tag: G.literal,
+		class: "tok-literal"
+	},
+	{
+		tag: G.string,
+		class: "tok-string"
+	},
+	{
+		tag: G.number,
+		class: "tok-number"
+	},
+	{
+		tag: [
+			G.regexp,
+			G.escape,
+			G.special(G.string)
+		],
+		class: "tok-string2"
+	},
+	{
+		tag: G.variableName,
+		class: "tok-variableName"
+	},
+	{
+		tag: G.local(G.variableName),
+		class: "tok-variableName tok-local"
+	},
+	{
+		tag: G.definition(G.variableName),
+		class: "tok-variableName tok-definition"
+	},
+	{
+		tag: G.special(G.variableName),
+		class: "tok-variableName2"
+	},
+	{
+		tag: G.definition(G.propertyName),
+		class: "tok-propertyName tok-definition"
+	},
+	{
+		tag: G.typeName,
+		class: "tok-typeName"
+	},
+	{
+		tag: G.namespace,
+		class: "tok-namespace"
+	},
+	{
+		tag: G.className,
+		class: "tok-className"
+	},
+	{
+		tag: G.macroName,
+		class: "tok-macroName"
+	},
+	{
+		tag: G.propertyName,
+		class: "tok-propertyName"
+	},
+	{
+		tag: G.operator,
+		class: "tok-operator"
+	},
+	{
+		tag: G.comment,
+		class: "tok-comment"
+	},
+	{
+		tag: G.meta,
+		class: "tok-meta"
+	},
+	{
+		tag: G.invalid,
+		class: "tok-invalid"
+	},
+	{
+		tag: G.punctuation,
+		class: "tok-punctuation"
+	}
+]);
+//#endregion
+//#region ../../node_modules/.bun/@codemirror+language@6.12.4/node_modules/@codemirror/language/dist/index.js
+var K = /*@__PURE__*/ new b();
+function Qe(e) {
+	return o.define({ combine: e ? (t) => t.concat(e) : void 0 });
+}
+var $e = /*@__PURE__*/ new b(), q = class {
+	constructor(e, t, n = [], r = "") {
+		this.data = e, this.name = r, i.prototype.hasOwnProperty("tree") || Object.defineProperty(i.prototype, "tree", { get() {
+			return J(this);
+		} }), this.parser = t, this.extension = [X.of(this), i.languageData.of((e, t, n) => {
+			let r = et(e, t, n), i = r.type.prop(K);
+			if (!i) return [];
+			let a = e.facet(i), o = r.type.prop($e);
+			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 et(e, t, n).type.prop(K) == this.data;
+	}
+	findRegions(e) {
+		let t = e.facet(X);
+		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(K) == this.data) {
+				n.push({
+					from: t,
+					to: t + e.length
+				});
+				return;
+			}
+			let i = e.prop(b.mounted);
+			if (i) {
+				if (i.tree.prop(K) == 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 D && r(i, e.positions[n] + t);
+			}
+		};
+		return r(J(e), 0), n;
+	}
+	get allowsNesting() {
+		return !0;
+	}
+};
+q.setState = /*@__PURE__*/ a.define();
+function et(e, t, n) {
+	let r = e.facet(X), i = J(e).topNode;
+	if (!r || r.allowsNesting) for (let e = i; e; e = e.enter(t, n, E.ExcludeBuffers | E.EnterBracketed)) e.type.isTop && (i = e);
+	return i;
+}
+var tt = class e extends q {
+	constructor(e, t, n) {
+		super(e, t, [], n), this.parser = t;
+	}
+	static define(t) {
+		let n = Qe(t.languageData);
+		return new e(n, t.parser.configure({ props: [K.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 J(e) {
+	let t = e.field(q.state, !1);
+	return t ? t.tree : D.empty;
+}
+var nt = 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);
+	}
+}, Y = null, rt = 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, [], D.empty, 0, r, [], null);
+	}
+	startParse() {
+		return this.parser.startParse(new nt(this.state.doc), this.fragments);
+	}
+	work(e, t) {
+		return t != null && t >= this.state.doc.length && (t = void 0), this.tree != D.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(N.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(N.addTree(this.tree, this.fragments, !0)), this.parse = null);
+	}
+	withContext(e) {
+		let t = Y;
+		Y = this;
+		try {
+			return e();
+		} finally {
+			Y = t;
+		}
+	}
+	withoutTempSkipped(e) {
+		for (let t; t = this.tempSkipped.pop();) e = it(e, t.from, t.to);
+		return e;
+	}
+	changes(t, n) {
+		let { fragments: r, tree: i, treeLen: a, viewport: o, skipped: s } = 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 = N.applyChanges(r, e), i = D.empty, a = 0, o = {
+				from: t.mapPos(o.from, -1),
+				to: t.mapPos(o.to, 1)
+			}, this.skipped.length) {
+				s = [];
+				for (let e of this.skipped) {
+					let n = t.mapPos(e.from, 1), r = t.mapPos(e.to, -1);
+					n < r && s.push({
+						from: n,
+						to: r
+					});
+				}
+			}
+		}
+		return new e(this.parser, n, r, i, a, o, s, 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 = it(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 _e {
+			createParse(t, n, r) {
+				let i = r[0].from, a = r[r.length - 1].to;
+				return {
+					parsedPos: i,
+					advance() {
+						let t = Y;
+						if (t) {
+							for (let e of r) t.tempSkipped.push(e);
+							e && (t.scheduleOn = t.scheduleOn ? Promise.all([t.scheduleOn, e]) : e);
+						}
+						return this.parsedPos = a, new D(C.none, [], [], a - i);
+					},
+					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 Y;
+	}
+};
+function it(e, t, n) {
+	return N.applyChanges(e, [{
+		fromA: t,
+		toA: n,
+		fromB: t,
+		toB: n
+	}]);
+}
+var at = 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 = rt.create(t.facet(X).parser, t, {
+			from: 0,
+			to: n
+		});
+		return r.work(20, n) || r.takeTree(), new e(r);
+	}
+};
+q.state = /*@__PURE__*/ r.define({
+	create: at.init,
+	update(e, t) {
+		for (let e of t.effects) if (e.is(q.setState)) return e.value;
+		return t.startState.facet(X) == t.state.facet(X) ? e.apply(t) : at.init(t.state);
+	}
+});
+var ot = (e) => {
+	let t = setTimeout(() => e(), 500);
+	return () => clearTimeout(t);
+};
+typeof requestIdleCallback < "u" && (ot = (e) => {
+	let t = -1, n = setTimeout(() => {
+		t = requestIdleCallback(e, { timeout: 400 });
+	}, 100);
+	return () => t < 0 ? clearTimeout(n) : cancelIdleCallback(t);
+});
+var st = typeof navigator < "u" && navigator.scheduling?.isInputPending ? () => navigator.scheduling.isInputPending() : null, ct = /*@__PURE__*/ u.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(q.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(q.state);
+		(t.tree != t.context.tree || !t.context.isDone(e.doc.length)) && (this.working = ot(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(q.state);
+		if (i.tree == i.context.tree && i.context.isDone(r + 1e5)) return;
+		let a = Date.now() + Math.min(this.chunkBudget, 100, e && !st ? Math.max(25, e.timeRemaining() - 5) : 1e9), o = i.context.treeLen < r && n.doc.length > r + 1e3, s = i.context.work(() => st && st() || Date.now() > a, r + (o ? 0 : 1e5));
+		this.chunkBudget -= Date.now() - t, (s || this.chunkBudget <= 0) && (i.context.takeTree(), this.view.dispatch({ effects: q.setState.of(new at(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) => l(this.view.state, e)).then(() => this.workScheduled--), null);
+	}
+	destroy() {
+		this.working && this.working();
+	}
+	isWorking() {
+		return !!(this.working || this.workScheduled > 0);
+	}
+}, { eventHandlers: { focus() {
+	this.scheduleWork();
+} } }), X = /*@__PURE__*/ o.define({
+	combine(e) {
+		return e.length ? e[0] : null;
+	},
+	enables: (e) => [
+		q.state,
+		ct,
+		g.contentAttributes.compute([e], (t) => {
+			let n = t.facet(e);
+			return n && n.name ? { "data-language": n.name } : {};
+		})
+	]
+}), lt = class {
+	constructor(e, t = []) {
+		this.language = e, this.support = t, this.extension = [e, t];
+	}
+}, ut = 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;
+	}
+}, dt = /*@__PURE__*/ o.define(), ft = /*@__PURE__*/ o.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 pt(e) {
+	let t = e.facet(ft);
+	return t.charCodeAt(0) == 9 ? e.tabSize * t.length : t.length;
+}
+function mt(e, t) {
+	let n = "", r = e.tabSize, i = e.facet(ft)[0];
+	if (i == "	") {
+		for (; t >= r;) n += "	", t -= r;
+		i = " ";
+	}
+	for (let e = 0; e < t; e++) n += i;
+	return n;
+}
+function ht(e, t) {
+	e instanceof i && (e = new gt(e));
+	for (let n of e.state.facet(dt)) {
+		let r = n(e, t);
+		if (r !== void 0) return r;
+	}
+	let n = J(e.state);
+	return n.length >= t ? vt(e, n, t) : null;
+}
+var gt = class {
+	constructor(e, t = {}) {
+		this.state = e, this.options = t, this.unit = pt(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(t, n = t.length) {
+		return e(t, this.state.tabSize, n);
+	}
+	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;
+	}
+}, _t = /*@__PURE__*/ new b();
+function vt(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 yt(r, e, n);
+}
+function yt(e, t, n) {
+	for (let r = e; r; r = r.next) {
+		let e = xt(r.node);
+		if (e) return e(Ct.create(t, n, r));
+	}
+	return 0;
+}
+function bt(e) {
+	return e.pos == e.options.simulateBreak && e.options.simulateDoubleBreak;
+}
+function xt(e) {
+	let t = e.type.prop(_t);
+	if (t) return t;
+	let n = e.firstChild, r;
+	if (n && (r = n.type.prop(b.closedBy))) {
+		let t = e.lastChild, n = t && r.indexOf(t.name) > -1;
+		return (e) => Dt(e, !0, 1, void 0, n && !bt(e) ? t.from : void 0);
+	}
+	return e.parent == null ? St : null;
+}
+function St() {
+	return 0;
+}
+var Ct = class e extends gt {
+	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 (wt(n, e)) break;
+			t = this.state.doc.lineAt(n.from);
+		}
+		return this.lineIndent(t.from);
+	}
+	continue() {
+		return yt(this.context.next, this.base, this.pos);
+	}
+};
+function wt(e, t) {
+	for (let n = t; n; n = n.parent) if (e == n) return !0;
+	return !1;
+}
+function Tt(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 Et({ closing: e, align: t = !0, units: n = 1 }) {
+	return (r) => Dt(r, t, n, e);
+}
+function Dt(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 ? Tt(e) : null;
+	return c ? s ? e.column(c.from) : e.column(c.to) : e.baseIndent + (s ? 0 : e.unit * n);
+}
+var Ot = (e) => e.baseIndent;
+function kt({ except: e, units: t = 1 } = {}) {
+	return (n) => {
+		let r = e && e.test(n.textAfter);
+		return n.baseIndent + (r ? 0 : t * n.unit);
+	};
+}
+var At = 200;
+function jt() {
+	return i.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 + At) 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 = ht(o, t.from);
+			if (n == null) continue;
+			let r = /^\s*/.exec(t.text)[0], i = mt(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 Mt = /*@__PURE__*/ o.define(), Nt = /*@__PURE__*/ new b();
+function Pt(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 Ft(e, t, n) {
+	let r = J(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(Nt);
+		if (s && (i.to < r.length - 50 || r.length == e.doc.length || !It(i))) {
+			let r = s(i, e);
+			r && r.from <= n && r.from >= t && r.to > n && (a = r);
+		}
+	}
+	return a;
+}
+function It(e) {
+	let t = e.lastChild;
+	return t && t.to == e.to && t.type.isError;
+}
+function Lt(e, t, n) {
+	for (let r of e.facet(Mt)) {
+		let i = r(e, t, n);
+		if (i) return i;
+	}
+	return Ft(e, t, n);
+}
+function Rt(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 zt = /*@__PURE__*/ a.define({ map: Rt }), Z = /*@__PURE__*/ a.define({ map: Rt });
+function Bt(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 Q = /*@__PURE__*/ r.define({
+	create() {
+		return _.none;
+	},
+	update(e, t) {
+		t.isUserEvent("delete") && t.changes.iterChangedRanges((t, n) => e = Vt(e, t, n)), e = e.map(t.changes);
+		let n = [];
+		for (let r of t.effects) r.is(zt) && !Ut(e, r.value.from, r.value.to) ? n.push(r.value) : r.is(Z) && (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(Xt), i = n.map((e) => (r ? _.replace({ widget: new en(r(t.state, e)) }) : $t).range(e.from, e.to));
+			e = e.update({ add: i });
+		}
+		return t.selection && (e = Vt(e, t.selection.main.head)), e;
+	},
+	provide: (e) => g.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($t.range(r, i));
+		}
+		return _.set(t, !0);
+	}
+});
+function Vt(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 Ht(e, t, n) {
+	var r;
+	let i = null;
+	return (r = e.field(Q, !1)) == null || r.between(t, n, (e, t) => {
+		(!i || i.from > e) && (i = {
+			from: e,
+			to: t
+		});
+	}), i;
+}
+function Ut(e, t, n) {
+	let r = !1;
+	return e.between(t, t, (e, i) => {
+		e == t && i == n && (r = !0);
+	}), r;
+}
+function Wt(e, t) {
+	return e.field(Q, !1) ? t : t.concat(a.appendConfig.of(Zt()));
+}
+var Gt = (e) => {
+	for (let t of Bt(e)) {
+		let n = Lt(e.state, t.from, t.to);
+		if (n) return e.dispatch({ effects: Wt(e.state, [zt.of(n), qt(e, n)]) }), !0;
+	}
+	return !1;
+}, Kt = (e) => {
+	if (!e.state.field(Q, !1)) return !1;
+	let t = [];
+	for (let n of Bt(e)) {
+		let r = Ht(e.state, n.from, n.to);
+		r && t.push(Z.of(r), qt(e, r, !1));
+	}
+	return t.length && e.dispatch({ effects: t }), t.length > 0;
+};
+function qt(e, t, n = !0) {
+	let r = e.state.doc.lineAt(t.from).number, i = e.state.doc.lineAt(t.to).number;
+	return g.announce.of(`${e.state.phrase(n ? "Folded lines" : "Unfolded lines")} ${r} ${e.state.phrase("to")} ${i}.`);
+}
+var Jt = [
+	{
+		key: "Ctrl-Shift-[",
+		mac: "Cmd-Alt-[",
+		run: Gt
+	},
+	{
+		key: "Ctrl-Shift-]",
+		mac: "Cmd-Alt-]",
+		run: Kt
+	},
+	{
+		key: "Ctrl-Alt-[",
+		run: (e) => {
+			let { state: t } = e, n = [];
+			for (let r = 0; r < t.doc.length;) {
+				let i = e.lineBlockAt(r), a = Lt(t, i.from, i.to);
+				a && n.push(zt.of(a)), r = (a ? e.lineBlockAt(a.to) : i).to + 1;
+			}
+			return n.length && e.dispatch({ effects: Wt(e.state, n) }), !!n.length;
+		}
+	},
+	{
+		key: "Ctrl-Alt-]",
+		run: (e) => {
+			let t = e.state.field(Q, !1);
+			if (!t || !t.size) return !1;
+			let n = [];
+			return t.between(0, e.state.doc.length, (e, t) => {
+				n.push(Z.of({
+					from: e,
+					to: t
+				}));
+			}), e.dispatch({ effects: n }), !0;
+		}
+	}
+], Yt = {
+	placeholderDOM: null,
+	preparePlaceholder: null,
+	placeholderText: "…"
+}, Xt = /*@__PURE__*/ o.define({ combine(e) {
+	return c(e, Yt);
+} });
+function Zt(e) {
+	let t = [Q, an];
+	return e && t.push(Xt.of(e)), t;
+}
+function Qt(e, t) {
+	let { state: n } = e, r = n.facet(Xt), i = (t) => {
+		let n = e.lineBlockAt(e.posAtDOM(t.target)), r = Ht(e.state, n.from, n.to);
+		r && e.dispatch({ effects: Z.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 $t = /*@__PURE__*/ _.replace({ widget: /*@__PURE__*/ new class extends h {
+	toDOM(e) {
+		return Qt(e, null);
+	}
+}() }), en = class extends h {
+	constructor(e) {
+		super(), this.value = e;
+	}
+	eq(e) {
+		return this.value == e.value;
+	}
+	toDOM(e) {
+		return Qt(e, this.value);
+	}
+}, tn = {
+	openText: "⌄",
+	closedText: "›",
+	markerDOM: null,
+	domEventHandlers: {},
+	foldingChanged: () => !1
+}, nn = class extends f {
+	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 rn(e = {}) {
+	let n = {
+		...tn,
+		...e
+	}, r = new nn(n, !0), i = new nn(n, !1), a = u.fromClass(class {
+		constructor(e) {
+			this.from = e.viewport.from, this.markers = this.buildMarkers(e);
+		}
+		update(e) {
+			(e.docChanged || e.viewportChanged || e.startState.facet(X) != e.state.facet(X) || e.startState.field(Q, !1) != e.state.field(Q, !1) || J(e.startState) != J(e.state) || n.foldingChanged(e)) && (this.markers = this.buildMarkers(e.view));
+		}
+		buildMarkers(e) {
+			let n = new t();
+			for (let t of e.viewportLineBlocks) {
+				let a = Ht(e.state, t.from, t.to) ? i : Lt(e.state, t.from, t.to) ? r : null;
+				a && n.add(t.from, t.from, a);
+			}
+			return n.finish();
+		}
+	}), { domEventHandlers: o } = n;
+	return [
+		a,
+		d({
+			class: "cm-foldGutter",
+			markers(e) {
+				return e.plugin(a)?.markers || s.empty;
+			},
+			initialSpacer() {
+				return new nn(n, !1);
+			},
+			domEventHandlers: {
+				...o,
+				click: (e, t, n) => {
+					if (o.click && o.click(e, t, n)) return !0;
+					let r = Ht(e.state, t.from, t.to);
+					if (r) return e.dispatch({ effects: Z.of(r) }), !0;
+					let i = Lt(e.state, t.from, t.to);
+					return i ? (e.dispatch({ effects: zt.of(i) }), !0) : !1;
+				}
+			}
+		}),
+		Zt()
+	];
+}
+var an = /*@__PURE__*/ g.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"
+	}
+}), on = class e {
+	constructor(e, t) {
+		this.specs = e;
+		let n;
+		function r(e) {
+			let t = p.newName();
+			return (n ||= Object.create(null))["." + t] = e, t;
+		}
+		let i = typeof t.all == "string" ? t.all : t.all ? r(t.all) : void 0, a = t.scope;
+		this.scope = a instanceof q ? (e) => e.prop(K) == a.data : a ? (e) => e == a : void 0, this.style = Be(e.map((e) => ({
+			tag: e.tag,
+			class: e.class || r(Object.assign({}, e, { tag: null }))
+		})), { all: i }).style, this.module = n ? new p(n) : null, this.themeType = t.themeType;
+	}
+	static define(t, n) {
+		return new e(t, n || {});
+	}
+}, sn = /*@__PURE__*/ o.define(), cn = /*@__PURE__*/ o.define({ combine(e) {
+	return e.length ? [e[0]] : null;
+} });
+function ln(e) {
+	let t = e.facet(sn);
+	return t.length ? t : e.facet(cn);
+}
+function un(e, t) {
+	let n = [pn], r;
+	return e instanceof on && (e.module && n.push(g.styleModule.of(e.module)), r = e.themeType), t?.fallback ? n.push(cn.of(e)) : r ? n.push(sn.computeN([g.darkTheme], (t) => t.facet(g.darkTheme) == (r == "dark") ? [e] : [])) : n.push(sn.of(e)), n;
+}
+function dn(e, t, n) {
+	let r = ln(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 fn = class {
+	constructor(e) {
+		this.markCache = Object.create(null), this.tree = J(e.state), this.decorations = this.buildDeco(e, ln(e.state)), this.decoratedTo = e.viewport.to;
+	}
+	update(e) {
+		let t = J(e.state), n = ln(e.state), r = n != ln(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, n) {
+		if (!n || !this.tree.length) return _.none;
+		let r = new t();
+		for (let { from: t, to: i } of e.visibleRanges) He(this.tree, n, (e, t, n) => {
+			r.add(e, t, this.markCache[n] || (this.markCache[n] = _.mark({ class: n })));
+		}, t, i);
+		return r.finish();
+	}
+}, pn = /*@__PURE__*/ n.high(/*@__PURE__*/ u.fromClass(fn, { decorations: (e) => e.decorations })), mn = /*@__PURE__*/ on.define([
+	{
+		tag: G.meta,
+		color: "#404740"
+	},
+	{
+		tag: G.link,
+		textDecoration: "underline"
+	},
+	{
+		tag: G.heading,
+		textDecoration: "underline",
+		fontWeight: "bold"
+	},
+	{
+		tag: G.emphasis,
+		fontStyle: "italic"
+	},
+	{
+		tag: G.strong,
+		fontWeight: "bold"
+	},
+	{
+		tag: G.strikethrough,
+		textDecoration: "line-through"
+	},
+	{
+		tag: G.keyword,
+		color: "#708"
+	},
+	{
+		tag: [
+			G.atom,
+			G.bool,
+			G.url,
+			G.contentSeparator,
+			G.labelName
+		],
+		color: "#219"
+	},
+	{
+		tag: [G.literal, G.inserted],
+		color: "#164"
+	},
+	{
+		tag: [G.string, G.deleted],
+		color: "#a11"
+	},
+	{
+		tag: [
+			G.regexp,
+			G.escape,
+			/*@__PURE__*/ G.special(G.string)
+		],
+		color: "#e40"
+	},
+	{
+		tag: /*@__PURE__*/ G.definition(G.variableName),
+		color: "#00f"
+	},
+	{
+		tag: /*@__PURE__*/ G.local(G.variableName),
+		color: "#30a"
+	},
+	{
+		tag: [G.typeName, G.namespace],
+		color: "#085"
+	},
+	{
+		tag: G.className,
+		color: "#167"
+	},
+	{
+		tag: [/*@__PURE__*/ G.special(G.variableName), G.macroName],
+		color: "#256"
+	},
+	{
+		tag: /*@__PURE__*/ G.definition(G.propertyName),
+		color: "#00c"
+	},
+	{
+		tag: G.comment,
+		color: "#940"
+	},
+	{
+		tag: G.invalid,
+		color: "#f00"
+	}
+]), hn = /*@__PURE__*/ g.baseTheme({
+	"&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+	"&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+}), gn = 1e4, _n = "()[]{}", vn = /*@__PURE__*/ o.define({ combine(e) {
+	return c(e, {
+		afterCursor: !0,
+		brackets: _n,
+		maxScanDistance: gn,
+		renderMatch: xn
+	});
+} }), yn = /*@__PURE__*/ _.mark({ class: "cm-matchingBracket" }), bn = /*@__PURE__*/ _.mark({ class: "cm-nonmatchingBracket" });
+function xn(e) {
+	let t = [], n = e.matched ? yn : bn;
+	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 Sn(e) {
+	let t = [], n = e.facet(vn);
+	for (let r of e.selection.ranges) {
+		if (!r.empty) continue;
+		let i = $(e, r.head, -1, n) || r.head > 0 && $(e, r.head - 1, 1, n) || n.afterCursor && ($(e, r.head, 1, n) || r.head < e.doc.length && $(e, r.head + 1, -1, n));
+		i && (t = t.concat(n.renderMatch(i, e)));
+	}
+	return _.set(t, !0);
+}
+var Cn = [/* @__PURE__ */ u.fromClass(class {
+	constructor(e) {
+		this.paused = !1, this.decorations = Sn(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 = Sn(e.state), this.paused = !1));
+	}
+}, { decorations: (e) => e.decorations }), hn];
+function wn(e = {}) {
+	return [vn.of(e), Cn];
+}
+var Tn = /*@__PURE__*/ new b();
+function En(e, t, n) {
+	let r = e.prop(t < 0 ? b.openedBy : b.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 Dn(e) {
+	let t = e.type.prop(Tn);
+	return t ? t(e.node) : e;
+}
+function $(e, t, n, r = {}) {
+	let i = r.maxScanDistance || gn, a = r.brackets || _n, o = J(e), s = o.resolveInner(t, n);
+	for (let r = s; r; r = r.parent) {
+		let i = En(r.type, n, a);
+		if (i && r.from < r.to) {
+			let o = Dn(r);
+			if (o && (n > 0 ? t >= o.from && t < o.to : t > o.from && t <= o.to)) return On(e, t, n, r, o, i, a);
+		}
+	}
+	return kn(e, t, n, o, s.type, i, a);
+}
+function On(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 = Dn(u);
+				return {
+					start: c,
+					end: e ? {
+						from: e.from,
+						to: e.to
+					} : void 0,
+					matched: !0
+				};
+			}
+			if (En(u.type, n, o)) l++;
+			else if (En(u.type, -n, o)) {
+				if (l == 0) {
+					let e = Dn(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 kn(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;
+}
+var An = /*@__PURE__*/ Object.create(null), jn = [C.none], Mn = [], Nn = /*@__PURE__*/ Object.create(null), Pn = /*@__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"]
+]) Pn[e] = /*@__PURE__*/ In(An, t);
+function Fn(e, t) {
+	Mn.indexOf(e) > -1 || (Mn.push(e), console.warn(t));
+}
+function In(e, t) {
+	let n = [];
+	for (let r of t.split(" ")) {
+		let t = [];
+		for (let n of r.split(".")) {
+			let r = e[n] || G[n];
+			r ? typeof r == "function" ? t.length ? t = t.map(r) : Fn(n, `Modifier ${n} used at start of tag`) : t.length ? Fn(n, `Tag ${n} used as modifier`) : t = Array.isArray(r) ? r : [r] : Fn(n, `Unknown highlighting tag ${n}`);
+		}
+		for (let e of t) n.push(e);
+	}
+	if (!n.length) return 0;
+	let r = t.replace(/ /g, "_"), i = r + " " + n.map((e) => e.id), a = Nn[i];
+	if (a) return a.id;
+	let o = Nn[i] = C.define({
+		id: jn.length,
+		name: r,
+		props: [Re({ [r]: n })]
+	});
+	return jn.push(o), o.id;
+}
+m.RTL, m.LTR;
+//#endregion
+export { $e as A, te as B, _t as C, X as D, ft as E, Re as F, ye as G, ge as H, G as I, ee as L, J as M, P as N, K as O, Ue as P, E as R, dn as S, mt as T, _e as U, C as V, D as W, Jt as _, ut as a, pt as b, wn as c, mn as d, Qe as f, Pt as g, rn as h, q as i, un as j, $ as k, Tn as l, Ot as m, gt as n, lt as o, Et as p, tt as r, rt as s, on as t, kt as u, Nt as v, jt as w, ht as x, Mt as y, b as z };