@burdenoff/microfe-technospam 2026.1102.1 → 2026.1102.2

package/dist/node_modules/@codemirror/language/dist/index.js

@@ -0,0 +1,957 @@
+import { EditorState as e, Facet as t, Prec as n, RangeSetBuilder as r, StateEffect as i, StateField as a, combineConfig as o, countColumn as s } from "../../state/dist/index.js";
+import { StyleModule as c } from "../../../style-mod/src/style-mod.js";
+import { Decoration as l, Direction as u, EditorView as d, ViewPlugin as f, logException as ee } from "../../view/dist/index.js";
+import { IterMode as te, NodeProp as p, NodeSet as ne, NodeType as m, Parser as re, Tree as h, TreeFragment as g } from "../../../@lezer/common/dist/index.js";
+import { highlightTree as ie, styleTags as ae, tagHighlighter as oe, tags as _ } from "../../../@lezer/highlight/dist/index.js";
+import { StringStream as se } from "../../streamparser/dist/index.js";
+//#region node_modules/@codemirror/language/dist/index.js
+var v = /* @__PURE__ */ new p();
+function y(e) {
+	return t.define({ combine: e ? (t) => t.concat(e) : void 0 });
+}
+var b = /* @__PURE__ */ new p(), x = class {
+	constructor(t, n, r = [], i = "") {
+		this.data = t, this.name = i, e.prototype.hasOwnProperty("tree") || Object.defineProperty(e.prototype, "tree", { get() {
+			return C(this);
+		} }), this.parser = n, this.extension = [O.of(this), e.languageData.of((e, t, n) => {
+			let r = S(e, t, n), i = r.type.prop(v);
+			if (!i) return [];
+			let a = e.facet(i), o = r.type.prop(b);
+			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(r);
+	}
+	isActiveAt(e, t, n = -1) {
+		return S(e, t, n).type.prop(v) == this.data;
+	}
+	findRegions(e) {
+		let t = e.facet(O);
+		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(v) == this.data) {
+				n.push({
+					from: t,
+					to: t + e.length
+				});
+				return;
+			}
+			let i = e.prop(p.mounted);
+			if (i) {
+				if (i.tree.prop(v) == 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;
+				} else 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 h && r(i, e.positions[n] + t);
+			}
+		};
+		return r(C(e), 0), n;
+	}
+	get allowsNesting() {
+		return !0;
+	}
+};
+x.setState = /* @__PURE__ */ i.define();
+function S(e, t, n) {
+	let r = e.facet(O), i = C(e).topNode;
+	if (!r || r.allowsNesting) for (let e = i; e; e = e.enter(t, n, te.ExcludeBuffers | te.EnterBracketed)) e.type.isTop && (i = e);
+	return i;
+}
+var ce = class e extends x {
+	constructor(e, t, n) {
+		super(e, t, [], n), this.parser = t;
+	}
+	static define(t) {
+		let n = y(t.languageData);
+		return new e(n, t.parser.configure({ props: [v.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 C(e) {
+	let t = e.field(x.state, !1);
+	return t ? t.tree : h.empty;
+}
+var le = 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);
+	}
+}, w = null, T = 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, [], h.empty, 0, r, [], null);
+	}
+	startParse() {
+		return this.parser.startParse(new le(this.state.doc), this.fragments);
+	}
+	work(e, t) {
+		return t != null && t >= this.state.doc.length && (t = void 0), this.tree != h.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(g.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(g.addTree(this.tree, this.fragments, !0)), this.parse = null);
+	}
+	withContext(e) {
+		let t = w;
+		w = this;
+		try {
+			return e();
+		} finally {
+			w = t;
+		}
+	}
+	withoutTempSkipped(e) {
+		for (let t; t = this.tempSkipped.pop();) e = ue(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 = g.applyChanges(r, e), i = h.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 = ue(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 re {
+			createParse(t, n, r) {
+				let i = r[0].from, a = r[r.length - 1].to;
+				return {
+					parsedPos: i,
+					advance() {
+						let t = w;
+						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 h(m.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 w;
+	}
+};
+function ue(e, t, n) {
+	return g.applyChanges(e, [{
+		fromA: t,
+		toA: n,
+		fromB: t,
+		toB: n
+	}]);
+}
+var E = 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 = T.create(t.facet(O).parser, t, {
+			from: 0,
+			to: n
+		});
+		return r.work(20, n) || r.takeTree(), new e(r);
+	}
+};
+x.state = /* @__PURE__ */ a.define({
+	create: E.init,
+	update(e, t) {
+		for (let e of t.effects) if (e.is(x.setState)) return e.value;
+		return t.startState.facet(O) == t.state.facet(O) ? e.apply(t) : E.init(t.state);
+	}
+});
+var de = (e) => {
+	let t = setTimeout(() => e(), 500);
+	return () => clearTimeout(t);
+};
+typeof requestIdleCallback < "u" && (de = (e) => {
+	let t = -1, n = setTimeout(() => {
+		t = requestIdleCallback(e, { timeout: 400 });
+	}, 100);
+	return () => t < 0 ? clearTimeout(n) : cancelIdleCallback(t);
+});
+var D = typeof navigator < "u" && navigator.scheduling?.isInputPending ? () => navigator.scheduling.isInputPending() : null, fe = /* @__PURE__ */ f.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(x.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(x.state);
+		(t.tree != t.context.tree || !t.context.isDone(e.doc.length)) && (this.working = de(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(x.state);
+		if (i.tree == i.context.tree && i.context.isDone(r + 1e5)) return;
+		let a = Date.now() + Math.min(this.chunkBudget, 100, e && !D ? Math.max(25, e.timeRemaining() - 5) : 1e9), o = i.context.treeLen < r && n.doc.length > r + 1e3, s = i.context.work(() => D && D() || Date.now() > a, r + (o ? 0 : 1e5));
+		this.chunkBudget -= Date.now() - t, (s || this.chunkBudget <= 0) && (i.context.takeTree(), this.view.dispatch({ effects: x.setState.of(new E(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) => ee(this.view.state, e)).then(() => this.workScheduled--), null);
+	}
+	destroy() {
+		this.working && this.working();
+	}
+	isWorking() {
+		return !!(this.working || this.workScheduled > 0);
+	}
+}, { eventHandlers: { focus() {
+	this.scheduleWork();
+} } }), O = /* @__PURE__ */ t.define({
+	combine(e) {
+		return e.length ? e[0] : null;
+	},
+	enables: (e) => [
+		x.state,
+		fe,
+		d.contentAttributes.compute([e], (t) => {
+			let n = t.facet(e);
+			return n && n.name ? { "data-language": n.name } : {};
+		})
+	]
+}), pe = class {
+	constructor(e, t = []) {
+		this.language = e, this.support = t, this.extension = [e, t];
+	}
+}, me = /* @__PURE__ */ t.define(), k = /* @__PURE__ */ t.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 A(e) {
+	let t = e.facet(k);
+	return t.charCodeAt(0) == 9 ? e.tabSize * t.length : t.length;
+}
+function j(e, t) {
+	let n = "", r = e.tabSize, i = e.facet(k)[0];
+	if (i == "	") {
+		for (; t >= r;) n += "	", t -= r;
+		i = " ";
+	}
+	for (let e = 0; e < t; e++) n += i;
+	return n;
+}
+function M(t, n) {
+	t instanceof e && (t = new N(t));
+	for (let e of t.state.facet(me)) {
+		let r = e(t, n);
+		if (r !== void 0) return r;
+	}
+	let r = C(t.state);
+	return r.length >= n ? he(t, r, n) : null;
+}
+var N = class {
+	constructor(e, t = {}) {
+		this.state = e, this.options = t, this.unit = A(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 s(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;
+	}
+}, P = /* @__PURE__ */ new p();
+function he(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 F(r, e, n);
+}
+function F(e, t, n) {
+	for (let r = e; r; r = r.next) {
+		let e = _e(r.node);
+		if (e) return e(ye.create(t, n, r));
+	}
+	return 0;
+}
+function ge(e) {
+	return e.pos == e.options.simulateBreak && e.options.simulateDoubleBreak;
+}
+function _e(e) {
+	let t = e.type.prop(P);
+	if (t) return t;
+	let n = e.firstChild, r;
+	if (n && (r = n.type.prop(p.closedBy))) {
+		let t = e.lastChild, n = t && r.indexOf(t.name) > -1;
+		return (e) => I(e, !0, 1, void 0, n && !ge(e) ? t.from : void 0);
+	}
+	return e.parent == null ? ve : null;
+}
+function ve() {
+	return 0;
+}
+var ye = class e extends N {
+	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 (be(n, e)) break;
+			t = this.state.doc.lineAt(n.from);
+		}
+		return this.lineIndent(t.from);
+	}
+	continue() {
+		return F(this.context.next, this.base, this.pos);
+	}
+};
+function be(e, t) {
+	for (let n = t; n; n = n.parent) if (e == n) return !0;
+	return !1;
+}
+function xe(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 Se({ closing: e, align: t = !0, units: n = 1 }) {
+	return (r) => I(r, t, n, e);
+}
+function I(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 ? xe(e) : null;
+	return c ? s ? e.column(c.from) : e.column(c.to) : e.baseIndent + (s ? 0 : e.unit * n);
+}
+var Ce = (e) => e.baseIndent;
+function we({ except: e, units: t = 1 } = {}) {
+	return (n) => {
+		let r = e && e.test(n.textAfter);
+		return n.baseIndent + (r ? 0 : t * n.unit);
+	};
+}
+var Te = 200;
+function Ee() {
+	return e.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 + Te) 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 = M(o, t.from);
+			if (n == null) continue;
+			let r = /^\s*/.exec(t.text)[0], i = j(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 De = /* @__PURE__ */ new p();
+function Oe(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;
+}
+var L = class e {
+	constructor(e, t) {
+		this.specs = e;
+		let n;
+		function r(e) {
+			let t = c.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 x ? (e) => e.prop(v) == a.data : a ? (e) => e == a : void 0, this.style = oe(e.map((e) => ({
+			tag: e.tag,
+			class: e.class || r(Object.assign({}, e, { tag: null }))
+		})), { all: i }).style, this.module = n ? new c(n) : null, this.themeType = t.themeType;
+	}
+	static define(t, n) {
+		return new e(t, n || {});
+	}
+}, R = /* @__PURE__ */ t.define(), z = /* @__PURE__ */ t.define({ combine(e) {
+	return e.length ? [e[0]] : null;
+} });
+function B(e) {
+	let t = e.facet(R);
+	return t.length ? t : e.facet(z);
+}
+function ke(e, t) {
+	let n = [je], r;
+	return e instanceof L && (e.module && n.push(d.styleModule.of(e.module)), r = e.themeType), t?.fallback ? n.push(z.of(e)) : r ? n.push(R.computeN([d.darkTheme], (t) => t.facet(d.darkTheme) == (r == "dark") ? [e] : [])) : n.push(R.of(e)), n;
+}
+var Ae = class {
+	constructor(e) {
+		this.markCache = Object.create(null), this.tree = C(e.state), this.decorations = this.buildDeco(e, B(e.state)), this.decoratedTo = e.viewport.to;
+	}
+	update(e) {
+		let t = C(e.state), n = B(e.state), r = n != B(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 l.none;
+		let n = new r();
+		for (let { from: r, to: i } of e.visibleRanges) ie(this.tree, t, (e, t, r) => {
+			n.add(e, t, this.markCache[r] || (this.markCache[r] = l.mark({ class: r })));
+		}, r, i);
+		return n.finish();
+	}
+}, je = /* @__PURE__ */ n.high(/* @__PURE__ */ f.fromClass(Ae, { decorations: (e) => e.decorations }));
+_.meta, _.link, _.heading, _.emphasis, _.strong, _.strikethrough, _.keyword, _.atom, _.bool, _.url, _.contentSeparator, _.labelName, _.literal, _.inserted, _.string, _.deleted, _.regexp, _.escape, _.string, _.variableName, _.variableName, _.typeName, _.namespace, _.className, _.variableName, _.macroName, _.propertyName, _.comment, _.invalid;
+var Me = /* @__PURE__ */ d.baseTheme({
+	"&.cm-focused .cm-matchingBracket": { backgroundColor: "#328c8252" },
+	"&.cm-focused .cm-nonmatchingBracket": { backgroundColor: "#bb555544" }
+}), V = 1e4, H = "()[]{}", U = /* @__PURE__ */ t.define({ combine(e) {
+	return o(e, {
+		afterCursor: !0,
+		brackets: H,
+		maxScanDistance: V,
+		renderMatch: Fe
+	});
+} }), Ne = /* @__PURE__ */ l.mark({ class: "cm-matchingBracket" }), Pe = /* @__PURE__ */ l.mark({ class: "cm-nonmatchingBracket" });
+function Fe(e) {
+	let t = [], n = e.matched ? Ne : Pe;
+	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 W(e) {
+	let t = [], n = e.facet(U);
+	for (let r of e.selection.ranges) {
+		if (!r.empty) continue;
+		let i = q(e, r.head, -1, n) || r.head > 0 && q(e, r.head - 1, 1, n) || n.afterCursor && (q(e, r.head, 1, n) || r.head < e.doc.length && q(e, r.head + 1, -1, n));
+		i && (t = t.concat(n.renderMatch(i, e)));
+	}
+	return l.set(t, !0);
+}
+var Ie = [/* @__PURE__ */ f.fromClass(class {
+	constructor(e) {
+		this.paused = !1, this.decorations = W(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 = W(e.state), this.paused = !1));
+	}
+}, { decorations: (e) => e.decorations }), Me];
+function Le(e = {}) {
+	return [U.of(e), Ie];
+}
+var Re = /* @__PURE__ */ new p();
+function G(e, t, n) {
+	let r = e.prop(t < 0 ? p.openedBy : p.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 K(e) {
+	let t = e.type.prop(Re);
+	return t ? t(e.node) : e;
+}
+function q(e, t, n, r = {}) {
+	let i = r.maxScanDistance || V, a = r.brackets || H, o = C(e), s = o.resolveInner(t, n);
+	for (let r = s; r; r = r.parent) {
+		let i = G(r.type, n, a);
+		if (i && r.from < r.to) {
+			let o = K(r);
+			if (o && (n > 0 ? t >= o.from && t < o.to : t > o.from && t <= o.to)) return ze(e, t, n, r, o, i, a);
+		}
+	}
+	return Be(e, t, n, o, s.type, i, a);
+}
+function ze(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 = K(u);
+				return {
+					start: c,
+					end: e ? {
+						from: e.from,
+						to: e.to
+					} : void 0,
+					matched: !0
+				};
+			} else if (G(u.type, n, o)) l++;
+			else if (G(u.type, -n, o)) {
+				if (l == 0) {
+					let e = K(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 Be(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 Ve(e) {
+	return {
+		name: e.name || "",
+		token: e.token,
+		blankLine: e.blankLine || (() => {}),
+		startState: e.startState || (() => !0),
+		copyState: e.copyState || He,
+		indent: e.indent || (() => null),
+		languageData: e.languageData || {},
+		tokenTable: e.tokenTable || X,
+		mergeTokens: e.mergeTokens !== !1
+	};
+}
+function He(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 J = /* @__PURE__ */ new WeakMap(), Ue = class e extends x {
+	constructor(e) {
+		let t = y(e.languageData), n = Ve(e), r, i = new class extends re {
+			createParse(e, t, n) {
+				return new Ke(r, e, t, n);
+			}
+		}();
+		super(t, i, [], e.name), this.topNode = et(t, this), r = this, this.streamParser = n, this.stateAfter = new p({ perNode: !0 }), this.tokenTable = e.tokenTable ? new Qe(n.tokenTable) : $e;
+	}
+	static define(t) {
+		return new e(t);
+	}
+	getIndent(e) {
+		let t, { overrideIndentation: n } = e.options;
+		n && (t = J.get(e.state), t != null && t < e.pos - 1e4 && (t = void 0));
+		let r = Y(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 se(t.text, e.state.tabSize, e.unit, i < 0 ? void 0 : i);
+				for (; o.pos < r - t.from;) qe(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 && J.set(e.state, o.from), this.streamParser.indent(a, /^\s*(.*)/.exec(o.text)[1], e);
+	}
+	get allowsNesting() {
+		return !1;
+	}
+};
+function Y(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], s = n + t.positions[a], c = o instanceof h && s < i && Y(e, o, s, r, i);
+		if (c) return c;
+	}
+	return null;
+}
+function We(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], s = t.children[a], c;
+		if (o < r && s instanceof h) {
+			if (!(c = We(e, s, n - o, r - o, i))) break;
+			return i ? new h(t.type, t.children.slice(0, a).concat(c), t.positions.slice(0, a + 1), o + c.length) : c;
+		}
+	}
+	return null;
+}
+function Ge(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 && Y(e, i.tree, 0 - i.offset, n, a), s;
+		if (o && o.pos <= r && (s = We(e, i.tree, n + i.offset, o.pos + i.offset, !1))) return {
+			state: o.state,
+			tree: s
+		};
+	}
+	return {
+		state: e.streamParser.startState(i ? A(i) : 4),
+		tree: h.empty
+	};
+}
+var Ke = 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 = T.get(), a = r[0].from, { state: o, tree: s } = Ge(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(A(i.state)), i.skipUntilInView(this.parsedPos, i.viewport.from), this.parsedPos = i.viewport.from), this.moveRangeIndex();
+	}
+	advance() {
+		let e = T.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 se(t, e ? e.state.tabSize : 4, e ? A(e.state) : 2);
+		if (a.eol()) i.blankLine(this.state, a.indentUnit);
+		else for (; !a.eol();) {
+			let e = qe(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 = h.build({
+			buffer: this.chunk,
+			start: this.chunkStart,
+			length: this.parsedPos - this.chunkStart,
+			nodeSet: Je,
+			topID: 0,
+			maxBufferLength: 512,
+			reused: this.chunkReused
+		});
+		e = new h(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 h(this.lang.topNode, this.chunks, this.chunkPos, this.parsedPos - this.ranges[0].from).balance();
+	}
+};
+function qe(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 X = /* @__PURE__ */ Object.create(null), Z = [m.none], Je = /* @__PURE__ */ new ne(Z), Ye = [], Xe = /* @__PURE__ */ Object.create(null), Ze = /* @__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"]
+]) Ze[e] = /* @__PURE__ */ $(X, t);
+var Qe = class {
+	constructor(e) {
+		this.extra = e, this.table = Object.assign(Object.create(null), Ze);
+	}
+	resolve(e) {
+		return e ? this.table[e] || (this.table[e] = $(this.extra, e)) : 0;
+	}
+}, $e = /* @__PURE__ */ new Qe(X);
+function Q(e, t) {
+	Ye.indexOf(e) > -1 || (Ye.push(e), console.warn(t));
+}
+function $(e, t) {
+	let n = [];
+	for (let r of t.split(" ")) {
+		let t = [];
+		for (let n of r.split(".")) {
+			let r = e[n] || _[n];
+			r ? typeof r == "function" ? t.length ? t = t.map(r) : Q(n, `Modifier ${n} used at start of tag`) : t.length ? Q(n, `Tag ${n} used as modifier`) : t = Array.isArray(r) ? r : [r] : Q(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 = Xe[i];
+	if (a) return a.id;
+	let o = Xe[i] = m.define({
+		id: Z.length,
+		name: r,
+		props: [ae({ [r]: n })]
+	});
+	return Z.push(o), o.id;
+}
+function et(e, t) {
+	let n = m.define({
+		id: Z.length,
+		name: "Document",
+		props: [v.add(() => e), P.add(() => (e) => t.getIndent(e))],
+		top: !0
+	});
+	return Z.push(n), n;
+}
+u.RTL, u.LTR;
+//#endregion
+export { L as HighlightStyle, N as IndentContext, ce as LRLanguage, pe as LanguageSupport, Ue as StreamLanguage, Le as bracketMatching, we as continuedIndent, y as defineLanguageFacet, Se as delimitedIndent, Ce as flatIndent, Oe as foldInside, De as foldNodeProp, A as getIndentUnit, M as getIndentation, P as indentNodeProp, Ee as indentOnInput, j as indentString, k as indentUnit, q as matchBrackets, b as sublanguageProp, ke as syntaxHighlighting, C as syntaxTree };
+
+//# sourceMappingURL=index.js.map