@mx-space/cli 0.1.0

package/dist/LexicalExtension.prod-Ug6emhEO.mjs

@@ -0,0 +1,971 @@
+import { $n as safeCast, An as createState, At as COMMAND_PRIORITY_LOW, Cn as TabNode, Dn as configExtension, Dt as COMMAND_PRIORITY_CRITICAL, G as $isBlockElementNode, Gt as FORMAT_TEXT_COMMAND, Hn as isDOMNode, I as $getNodeFromDOMNode, In as getStaticNodeConfig, J as $isEditorState, Mn as defineExtension, On as createCommand, Ot as COMMAND_PRIORITY_EDITOR, P as $getNodeByKey, Qn as removeClassNamesFromElement, Qt as INSERT_TAB_COMMAND, R as $getRoot, Sn as TEXT_TYPE_TO_FORMAT, Tn as addClassNamesToElement, Tt as CLICK_COMMAND, V as $getState, Vt as DecoratorNode, Xn as mergeRegister, Yt as INDENT_CONTENT_COMMAND, bt as $setState, d as $createNodeSelection, dn as OUTDENT_CONTENT_COMMAND, f as $createParagraphNode, ft as $normalizeSelection__EXPERIMENTAL, gn as RootNode, ir as toggleTextFormatType, j as $getEditor, jn as declarePeerDependency, kn as createEditor, l as $create, ln as KEY_TAB_COMMAND, m as $createRangeSelection, mn as ParagraphNode, qt as HISTORY_MERGE_TAG, rr as shallowMergeConfig, rt as $isRangeSelection, tt as $isNodeSelection, un as LineBreakNode, vt as $setSelection, wn as TextNode, wt as CLEAR_EDITOR_COMMAND, z as $getSelection } from "./Lexical.node-gYNDt_p9.mjs";
+import { c as $insertNodeToNearestRoot, i as $getNearestBlockElementAncestorOrThrow, o as $handleIndentAndOutdent, v as selectionAlwaysOnDisplay } from "./LexicalUtils.node-CmK462d1.mjs";
+//#region ../../node_modules/.pnpm/@lexical+extension@0.44.0/node_modules/@lexical/extension/LexicalExtension.prod.mjs
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const Q = Symbol.for("preact-signals");
+function X() {
+	if (ot > 1) return void ot--;
+	let t, e = !1;
+	for (function() {
+		let t = it;
+		for (it = void 0; void 0 !== t;) t.S.v === t.v && (t.S.i = t.i), t = t.o;
+	}(); void 0 !== et;) {
+		let n = et;
+		for (et = void 0, st++; void 0 !== n;) {
+			const i = n.u;
+			if (n.u = void 0, n.f &= -3, !(8 & n.f) && lt(n)) try {
+				n.c();
+			} catch (n) {
+				e || (t = n, e = !0);
+			}
+			n = i;
+		}
+	}
+	if (st = 0, ot--, e) throw t;
+}
+function Y(t) {
+	if (ot > 0) return t();
+	ct = ++rt, ot++;
+	try {
+		return t();
+	} finally {
+		X();
+	}
+}
+let tt, et;
+function nt(t) {
+	const e = tt;
+	tt = void 0;
+	try {
+		return t();
+	} finally {
+		tt = e;
+	}
+}
+let it, ot = 0, st = 0, rt = 0, ct = 0, at = 0;
+function dt(t) {
+	if (void 0 === tt) return;
+	let e = t.n;
+	return void 0 === e || e.t !== tt ? (e = {
+		i: 0,
+		S: t,
+		p: tt.s,
+		n: void 0,
+		t: tt,
+		e: void 0,
+		x: void 0,
+		r: e
+	}, void 0 !== tt.s && (tt.s.n = e), tt.s = e, t.n = e, 32 & tt.f && t.S(e), e) : -1 === e.i ? (e.i = 0, void 0 !== e.n && (e.n.p = e.p, void 0 !== e.p && (e.p.n = e.n), e.p = tt.s, e.n = void 0, tt.s.n = e, tt.s = e), e) : void 0;
+}
+function ut(t, e) {
+	this.v = t, this.i = 0, this.n = void 0, this.t = void 0, this.l = 0, this.W = null == e ? void 0 : e.watched, this.Z = null == e ? void 0 : e.unwatched, this.name = null == e ? void 0 : e.name;
+}
+function ft(t, e) {
+	return new ut(t, e);
+}
+function lt(t) {
+	for (let e = t.s; void 0 !== e; e = e.n) if (e.S.i !== e.i || !e.S.h() || e.S.i !== e.i) return !0;
+	return !1;
+}
+function ht(t) {
+	for (let e = t.s; void 0 !== e; e = e.n) {
+		const n = e.S.n;
+		if (void 0 !== n && (e.r = n), e.S.n = e, e.i = -1, void 0 === e.n) {
+			t.s = e;
+			break;
+		}
+	}
+}
+function gt(t) {
+	let e, n = t.s;
+	for (; void 0 !== n;) {
+		const t = n.p;
+		-1 === n.i ? (n.S.U(n), void 0 !== t && (t.n = n.n), void 0 !== n.n && (n.n.p = t)) : e = n, n.S.n = n.r, void 0 !== n.r && (n.r = void 0), n = t;
+	}
+	t.s = e;
+}
+function pt(t, e) {
+	ut.call(this, void 0), this.x = t, this.s = void 0, this.g = at - 1, this.f = 4, this.W = null == e ? void 0 : e.watched, this.Z = null == e ? void 0 : e.unwatched, this.name = null == e ? void 0 : e.name;
+}
+function mt(t, e) {
+	return new pt(t, e);
+}
+function vt(t) {
+	const e = t.m;
+	if (t.m = void 0, "function" == typeof e) {
+		ot++;
+		const n = tt;
+		tt = void 0;
+		try {
+			e();
+		} catch (e) {
+			throw t.f &= -2, t.f |= 8, xt(t), e;
+		} finally {
+			tt = n, X();
+		}
+	}
+}
+function xt(t) {
+	for (let e = t.s; void 0 !== e; e = e.n) e.S.U(e);
+	t.x = void 0, t.s = void 0, vt(t);
+}
+function yt(t) {
+	if (tt !== this) throw new Error("Out-of-order effect");
+	gt(this), tt = t, this.f &= -2, 8 & this.f && xt(this), X();
+}
+function Et(t, e) {
+	this.x = t, this.m = void 0, this.s = void 0, this.u = void 0, this.f = 32, this.name = null == e ? void 0 : e.name;
+}
+function St(t, e) {
+	const n = new Et(t, e);
+	try {
+		n.c();
+	} catch (t) {
+		throw n.d(), t;
+	}
+	const i = n.d.bind(n);
+	return i[Symbol.dispose] = i, i;
+}
+function bt(t, e = {}) {
+	const n = {};
+	for (const i in t) {
+		const o = e[i];
+		n[i] = ft(void 0 === o ? t[i] : o);
+	}
+	return n;
+}
+ut.prototype.brand = Q, ut.prototype.h = function() {
+	return !0;
+}, ut.prototype.S = function(t) {
+	const e = this.t;
+	e !== t && void 0 === t.e && (t.x = e, this.t = t, void 0 !== e ? e.e = t : nt(() => {
+		var t;
+		null == (t = this.W) || t.call(this);
+	}));
+}, ut.prototype.U = function(t) {
+	if (void 0 !== this.t) {
+		const e = t.e, n = t.x;
+		void 0 !== e && (e.x = n, t.e = void 0), void 0 !== n && (n.e = e, t.x = void 0), t === this.t && (this.t = n, void 0 === n && nt(() => {
+			var t;
+			null == (t = this.Z) || t.call(this);
+		}));
+	}
+}, ut.prototype.subscribe = function(t) {
+	return St(() => {
+		const e = this.value, n = tt;
+		tt = void 0;
+		try {
+			t(e);
+		} finally {
+			tt = n;
+		}
+	}, { name: "sub" });
+}, ut.prototype.valueOf = function() {
+	return this.value;
+}, ut.prototype.toString = function() {
+	return this.value + "";
+}, ut.prototype.toJSON = function() {
+	return this.value;
+}, ut.prototype.peek = function() {
+	const t = tt;
+	tt = void 0;
+	try {
+		return this.value;
+	} finally {
+		tt = t;
+	}
+}, Object.defineProperty(ut.prototype, "value", {
+	get() {
+		const t = dt(this);
+		return void 0 !== t && (t.i = this.i), this.v;
+	},
+	set(t) {
+		if (t !== this.v) {
+			if (st > 100) throw new Error("Cycle detected");
+			(function(t) {
+				0 !== ot && 0 === st && t.l !== ct && (t.l = ct, it = {
+					S: t,
+					v: t.v,
+					i: t.i,
+					o: it
+				});
+			})(this), this.v = t, this.i++, at++, ot++;
+			try {
+				for (let t = this.t; void 0 !== t; t = t.x) t.t.N();
+			} finally {
+				X();
+			}
+		}
+	}
+}), pt.prototype = new ut(), pt.prototype.h = function() {
+	if (this.f &= -3, 1 & this.f) return !1;
+	if (32 == (36 & this.f)) return !0;
+	if (this.f &= -5, this.g === at) return !0;
+	if (this.g = at, this.f |= 1, this.i > 0 && !lt(this)) return this.f &= -2, !0;
+	const t = tt;
+	try {
+		ht(this), tt = this;
+		const t = this.x();
+		(16 & this.f || this.v !== t || 0 === this.i) && (this.v = t, this.f &= -17, this.i++);
+	} catch (t) {
+		this.v = t, this.f |= 16, this.i++;
+	}
+	return tt = t, gt(this), this.f &= -2, !0;
+}, pt.prototype.S = function(t) {
+	if (void 0 === this.t) {
+		this.f |= 36;
+		for (let t = this.s; void 0 !== t; t = t.n) t.S.S(t);
+	}
+	ut.prototype.S.call(this, t);
+}, pt.prototype.U = function(t) {
+	if (void 0 !== this.t && (ut.prototype.U.call(this, t), void 0 === this.t)) {
+		this.f &= -33;
+		for (let t = this.s; void 0 !== t; t = t.n) t.S.U(t);
+	}
+}, pt.prototype.N = function() {
+	if (!(2 & this.f)) {
+		this.f |= 6;
+		for (let t = this.t; void 0 !== t; t = t.x) t.t.N();
+	}
+}, Object.defineProperty(pt.prototype, "value", { get() {
+	if (1 & this.f) throw new Error("Cycle detected");
+	const t = dt(this);
+	if (this.h(), void 0 !== t && (t.i = this.i), 16 & this.f) throw this.v;
+	return this.v;
+} }), Et.prototype.c = function() {
+	const t = this.S();
+	try {
+		if (8 & this.f) return;
+		if (void 0 === this.x) return;
+		const t = this.x();
+		"function" == typeof t && (this.m = t);
+	} finally {
+		t();
+	}
+}, Et.prototype.S = function() {
+	if (1 & this.f) throw new Error("Cycle detected");
+	this.f |= 1, this.f &= -9, vt(this), ht(this), ot++;
+	const t = tt;
+	return tt = this, yt.bind(this, t);
+}, Et.prototype.N = function() {
+	2 & this.f || (this.f |= 2, this.u = et, et = this);
+}, Et.prototype.d = function() {
+	this.f |= 8, 1 & this.f || xt(this);
+}, Et.prototype.dispose = function() {
+	this.d();
+};
+const wt = defineExtension({
+	build: (t, e, n) => bt(e),
+	config: safeCast({
+		defaultSelection: "rootEnd",
+		disabled: !1
+	}),
+	name: "@lexical/extension/AutoFocus",
+	register(t, e, n) {
+		const i = n.getOutput();
+		return St(() => i.disabled.value ? void 0 : t.registerRootListener((e) => {
+			t.focus(() => {
+				const t = document.activeElement;
+				null === e || null !== t && e.contains(t) || e.focus({ preventScroll: !0 });
+			}, { defaultSelection: i.defaultSelection.peek() });
+		}));
+	}
+});
+function Nt() {
+	const t = $getRoot(), e = $getSelection(), n = $createParagraphNode();
+	t.clear(), t.append(n), null !== e && n.select(), $isRangeSelection(e) && (e.format = 0);
+}
+function Ot(t, e = Nt) {
+	return t.registerCommand(CLEAR_EDITOR_COMMAND, (n) => (t.update(e), !0), COMMAND_PRIORITY_EDITOR);
+}
+const Rt = defineExtension({
+	build: (t, e, n) => bt(e),
+	config: safeCast({ $onClear: Nt }),
+	name: "@lexical/extension/ClearEditor",
+	register(t, e, n) {
+		const { $onClear: i } = n.getOutput();
+		return St(() => Ot(t, i.value));
+	}
+});
+function Ct(t) {
+	const e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Set();
+	for (const i of Dt(t)) {
+		const t = "function" == typeof i ? i : i.replace;
+		getStaticNodeConfig(t), e.add(t.getType()), n.add(t);
+	}
+	return {
+		nodes: n,
+		types: e
+	};
+}
+function Dt(t) {
+	return ("function" == typeof t.nodes ? t.nodes() : t.nodes) || [];
+}
+const Ft = createState("format", { parse: (t) => "number" == typeof t ? t : 0 });
+var Mt = class extends DecoratorNode {
+	$config() {
+		return this.config("decorator-text", {
+			extends: DecoratorNode,
+			stateConfigs: [{
+				flat: !0,
+				stateConfig: Ft
+			}]
+		});
+	}
+	getFormat() {
+		return $getState(this, Ft);
+	}
+	getFormatFlags(t, e) {
+		return toggleTextFormatType(this.getFormat(), t, e);
+	}
+	hasFormat(t) {
+		const e = TEXT_TYPE_TO_FORMAT[t];
+		return 0 !== (this.getFormat() & e);
+	}
+	setFormat(t) {
+		return $setState(this, Ft, t);
+	}
+	toggleFormat(t) {
+		const n = toggleTextFormatType(this.getFormat(), t, null);
+		return this.setFormat(n);
+	}
+	isInline() {
+		return !0;
+	}
+	createDOM() {
+		return document.createElement("span");
+	}
+	updateDOM() {
+		return !1;
+	}
+};
+function It(t) {
+	return t instanceof Mt;
+}
+function _t(t, e, n) {
+	const i = e.fontWeight, o = e.textDecoration.split(" "), s = "700" === i || "bold" === i, r = o.includes("line-through"), c = "italic" === e.fontStyle, a = o.includes("underline"), d = e.verticalAlign;
+	return s && !t.hasFormat("bold") && t.toggleFormat("bold"), r && !t.hasFormat("strikethrough") && t.toggleFormat("strikethrough"), c && !t.hasFormat("italic") && t.toggleFormat("italic"), a && !t.hasFormat("underline") && t.toggleFormat("underline"), "sub" !== d || t.hasFormat("subscript") || t.toggleFormat("subscript"), "super" !== d || t.hasFormat("superscript") || t.toggleFormat("superscript"), n && !t.hasFormat(n) && t.toggleFormat(n), t;
+}
+function Pt(t, e, n = jt) {
+	for (const [i, o] of Object.entries(n)) t.hasFormat(o) && (e = At(e, i));
+	return e;
+}
+function At(t, e) {
+	const n = document.createElement(e);
+	return n.appendChild(t), n;
+}
+const jt = {
+	b: "bold",
+	code: "code",
+	em: "italic",
+	i: "italic",
+	mark: "highlight",
+	s: "strikethrough",
+	strong: "bold",
+	sub: "subscript",
+	sup: "superscript",
+	u: "underline"
+}, kt = defineExtension({
+	name: "@lexical/extension/DecoratorText",
+	nodes: () => [Mt],
+	register: (t, e, n) => t.registerCommand(FORMAT_TEXT_COMMAND, (t) => {
+		const e = $getSelection();
+		if ($isNodeSelection(e) || $isRangeSelection(e)) for (const n of e.getNodes()) It(n) && n.toggleFormat(t);
+		return !1;
+	}, COMMAND_PRIORITY_LOW)
+});
+function $t(t, e) {
+	let n;
+	return ft(t(), {
+		unwatched() {
+			n && (n(), n = void 0);
+		},
+		watched() {
+			this.value = t(), n = e(this);
+		}
+	});
+}
+const Kt = defineExtension({
+	build: (t) => $t(() => t.getEditorState(), (e) => t.registerUpdateListener((t) => {
+		e.value = t.editorState;
+	})),
+	name: "@lexical/extension/EditorState"
+});
+function zt(t, ...e) {
+	const n = new URL("https://lexical.dev/docs/error"), i = new URLSearchParams();
+	i.append("code", t);
+	for (const t of e) i.append("v", t);
+	throw n.search = i.toString(), Error(`Minified Lexical error #${t}; visit ${n.toString()} for the full message or use the non-minified dev environment for full errors and additional helpful warnings.`);
+}
+function Lt(t, e) {
+	if (t && e && !Array.isArray(e) && "object" == typeof t && "object" == typeof e) {
+		const n = t, i = e;
+		for (const t in i) n[t] = Lt(n[t], i[t]);
+		return t;
+	}
+	return e;
+}
+const Ut = 0, Tt = 1, Bt = 2, Wt = 3, Gt = 4, Vt = 5, Zt = 6, Jt = 7;
+function Ht(t) {
+	return t.id === Ut;
+}
+function qt(t) {
+	return t.id === Bt;
+}
+function Qt(t) {
+	return function(t) {
+		return t.id === Tt;
+	}(t) || zt(305, String(t.id), String(Tt)), Object.assign(t, { id: Bt });
+}
+const Xt = /* @__PURE__ */ new Set();
+var Yt = class {
+	builder;
+	configs;
+	_dependency;
+	_peerNameSet;
+	extension;
+	state;
+	_signal;
+	constructor(t, e) {
+		this.builder = t, this.extension = e, this.configs = /* @__PURE__ */ new Set(), this.state = { id: Ut };
+	}
+	mergeConfigs() {
+		let t = this.extension.config || {};
+		const e = this.extension.mergeConfig ? this.extension.mergeConfig.bind(this.extension) : shallowMergeConfig;
+		for (const n of this.configs) t = e(t, n);
+		return t;
+	}
+	init(t) {
+		const e = this.state;
+		qt(e) || zt(306, String(e.id));
+		const n = {
+			getDependency: this.getInitDependency.bind(this),
+			getDirectDependentNames: this.getDirectDependentNames.bind(this),
+			getPeer: this.getInitPeer.bind(this),
+			getPeerNameSet: this.getPeerNameSet.bind(this)
+		}, i = {
+			...n,
+			getDependency: this.getDependency.bind(this),
+			getInitResult: this.getInitResult.bind(this),
+			getPeer: this.getPeer.bind(this)
+		}, o = function(t, e, n) {
+			return Object.assign(t, {
+				config: e,
+				id: Wt,
+				registerState: n
+			});
+		}(e, this.mergeConfigs(), n);
+		let s;
+		this.state = o, this.extension.init && (s = this.extension.init(t, o.config, n)), this.state = function(t, e, n) {
+			return Object.assign(t, {
+				id: Gt,
+				initResult: e,
+				registerState: n
+			});
+		}(o, s, i);
+	}
+	build(t) {
+		const e = this.state;
+		let n;
+		e.id !== Gt && zt(307, String(e.id), String(Vt)), this.extension.build && (n = this.extension.build(t, e.config, e.registerState));
+		const i = {
+			...e.registerState,
+			getOutput: () => n,
+			getSignal: this.getSignal.bind(this)
+		};
+		this.state = function(t, e, n) {
+			return Object.assign(t, {
+				id: Vt,
+				output: e,
+				registerState: n
+			});
+		}(e, n, i);
+	}
+	register(t, e) {
+		this._signal = e;
+		const n = this.state;
+		n.id !== Vt && zt(308, String(n.id), String(Vt));
+		const i = this.extension.register && this.extension.register(t, n.config, n.registerState);
+		return this.state = function(t) {
+			return Object.assign(t, { id: Zt });
+		}(n), () => {
+			const t = this.state;
+			t.id !== Jt && zt(309, String(n.id), String(Jt)), this.state = function(t) {
+				return Object.assign(t, { id: Vt });
+			}(t), i && i();
+		};
+	}
+	afterRegistration(t) {
+		const e = this.state;
+		let n;
+		return e.id !== Zt && zt(310, String(e.id), String(Zt)), this.extension.afterRegistration && (n = this.extension.afterRegistration(t, e.config, e.registerState)), this.state = function(t) {
+			return Object.assign(t, { id: Jt });
+		}(e), n;
+	}
+	getSignal() {
+		return void 0 === this._signal && zt(311), this._signal;
+	}
+	getInitResult() {
+		void 0 === this.extension.init && zt(312, this.extension.name);
+		const t = this.state;
+		return function(t) {
+			return t.id >= Gt;
+		}(t) || zt(313, String(t.id), String(Gt)), t.initResult;
+	}
+	getInitPeer(t) {
+		const e = this.builder.extensionNameMap.get(t);
+		return e ? e.getExtensionInitDependency() : void 0;
+	}
+	getExtensionInitDependency() {
+		const t = this.state;
+		return function(t) {
+			return t.id >= Wt;
+		}(t) || zt(314, String(t.id), String(Wt)), { config: t.config };
+	}
+	getPeer(t) {
+		const e = this.builder.extensionNameMap.get(t);
+		return e ? e.getExtensionDependency() : void 0;
+	}
+	getInitDependency(t) {
+		const e = this.builder.getExtensionRep(t);
+		return void 0 === e && zt(315, this.extension.name, t.name), e.getExtensionInitDependency();
+	}
+	getDependency(t) {
+		const e = this.builder.getExtensionRep(t);
+		return void 0 === e && zt(315, this.extension.name, t.name), e.getExtensionDependency();
+	}
+	getState() {
+		const t = this.state;
+		return function(t) {
+			return t.id >= Jt;
+		}(t) || zt(316, String(t.id), String(Jt)), t;
+	}
+	getDirectDependentNames() {
+		return this.builder.incomingEdges.get(this.extension.name) || Xt;
+	}
+	getPeerNameSet() {
+		let t = this._peerNameSet;
+		return t || (t = new Set((this.extension.peerDependencies || []).map(([t]) => t)), this._peerNameSet = t), t;
+	}
+	getExtensionDependency() {
+		if (!this._dependency) {
+			const t = this.state;
+			(function(t) {
+				return t.id >= Vt;
+			})(t) || zt(317, this.extension.name), this._dependency = {
+				config: t.config,
+				init: t.initResult,
+				output: t.output
+			};
+		}
+		return this._dependency;
+	}
+};
+const te = { tag: HISTORY_MERGE_TAG };
+function ee() {
+	const t = $getRoot();
+	t.isEmpty() && t.append($createParagraphNode());
+}
+const ne = defineExtension({
+	config: safeCast({
+		setOptions: te,
+		updateOptions: te
+	}),
+	init: ({ $initialEditorState: t = ee }) => ({
+		$initialEditorState: t,
+		initialized: !1
+	}),
+	afterRegistration(t, { updateOptions: e, setOptions: n }, i) {
+		const o = i.getInitResult();
+		if (!o.initialized) {
+			o.initialized = !0;
+			const { $initialEditorState: i } = o;
+			if ($isEditorState(i)) t.setEditorState(i, n);
+			else if ("function" == typeof i) t.update(() => {
+				i(t);
+			}, e);
+			else if (i && ("string" == typeof i || "object" == typeof i)) {
+				const e = t.parseEditorState(i);
+				t.setEditorState(e, n);
+			}
+		}
+		return () => {};
+	},
+	name: "@lexical/extension/InitialState",
+	nodes: [
+		RootNode,
+		TextNode,
+		LineBreakNode,
+		TabNode,
+		ParagraphNode
+	]
+}), ie = Symbol.for("@lexical/extension/LexicalBuilder");
+function oe(...t) {
+	return de.fromExtensions(t).buildEditor();
+}
+function se() {}
+function re(t) {
+	throw t;
+}
+function ce(t) {
+	return Array.isArray(t) ? t : [t];
+}
+const ae = "0.44.0+prod.esm";
+var de = class de {
+	roots;
+	extensionNameMap;
+	outgoingConfigEdges;
+	incomingEdges;
+	conflicts;
+	_sortedExtensionReps;
+	PACKAGE_VERSION;
+	constructor(t) {
+		this.outgoingConfigEdges = /* @__PURE__ */ new Map(), this.incomingEdges = /* @__PURE__ */ new Map(), this.extensionNameMap = /* @__PURE__ */ new Map(), this.conflicts = /* @__PURE__ */ new Map(), this.PACKAGE_VERSION = ae, this.roots = t;
+		for (const e of t) this.addExtension(e);
+	}
+	static fromExtensions(t) {
+		const e = [ce(ne)];
+		for (const n of t) e.push(ce(n));
+		return new de(e);
+	}
+	static maybeFromEditor(t) {
+		const e = t[ie];
+		return e && (e.PACKAGE_VERSION !== ae && zt(292, e.PACKAGE_VERSION, ae), e instanceof de || zt(293)), e;
+	}
+	static fromEditor(t) {
+		const e = de.maybeFromEditor(t);
+		return void 0 === e && zt(294), e;
+	}
+	constructEditor() {
+		const { $initialEditorState: t, onError: e, ...n } = this.buildCreateEditorArgs(), i = Object.assign(createEditor({
+			...n,
+			...e ? { onError: (t) => {
+				e(t, i);
+			} } : {}
+		}), { [ie]: this });
+		for (const t of this.sortedExtensionReps()) t.build(i);
+		return i;
+	}
+	buildEditor() {
+		let t = se;
+		function e() {
+			try {
+				t();
+			} finally {
+				t = se;
+			}
+		}
+		const n = Object.assign(this.constructEditor(), {
+			dispose: e,
+			[Symbol.dispose]: e
+		});
+		return t = mergeRegister(this.registerEditor(n), () => n.setRootElement(null)), n;
+	}
+	hasExtensionByName(t) {
+		return this.extensionNameMap.has(t);
+	}
+	getExtensionRep(t) {
+		const e = this.extensionNameMap.get(t.name);
+		if (e) return e.extension !== t && zt(295, t.name), e;
+	}
+	addEdge(t, e, n) {
+		const i = this.outgoingConfigEdges.get(t);
+		i ? i.set(e, n) : this.outgoingConfigEdges.set(t, new Map([[e, n]]));
+		const o = this.incomingEdges.get(e);
+		o ? o.add(t) : this.incomingEdges.set(e, new Set([t]));
+	}
+	addExtension(t) {
+		void 0 !== this._sortedExtensionReps && zt(296);
+		const [n] = ce(t);
+		"string" != typeof n.name && zt(297, typeof n.name);
+		let i = this.extensionNameMap.get(n.name);
+		if (void 0 !== i && i.extension !== n && zt(298, n.name), !i) {
+			i = new Yt(this, n), this.extensionNameMap.set(n.name, i);
+			const t = this.conflicts.get(n.name);
+			"string" == typeof t && zt(299, n.name, t);
+			for (const t of n.conflictsWith || []) this.extensionNameMap.has(t) && zt(299, n.name, t), this.conflicts.set(t, n.name);
+			for (const t of n.dependencies || []) {
+				const e = ce(t);
+				this.addEdge(n.name, e[0].name, e.slice(1)), this.addExtension(e);
+			}
+			for (const [t, e] of n.peerDependencies || []) this.addEdge(n.name, t, e ? [e] : []);
+		}
+	}
+	sortedExtensionReps() {
+		if (this._sortedExtensionReps) return this._sortedExtensionReps;
+		const t = [], e = (n, i) => {
+			let o = n.state;
+			if (qt(o)) return;
+			const s = n.extension.name;
+			var r;
+			Ht(o) || zt(300, s, i || "[unknown]"), Ht(r = o) || zt(304, String(r.id), String(Ut)), o = Object.assign(r, { id: Tt }), n.state = o;
+			const c = this.outgoingConfigEdges.get(s);
+			if (c) for (const t of c.keys()) {
+				const n = this.extensionNameMap.get(t);
+				n && e(n, s);
+			}
+			o = Qt(o), n.state = o, t.push(n);
+		};
+		for (const t of this.extensionNameMap.values()) Ht(t.state) && e(t);
+		for (const e of t) for (const [t, n] of this.outgoingConfigEdges.get(e.extension.name) || []) if (n.length > 0) {
+			const e = this.extensionNameMap.get(t);
+			if (e) for (const t of n) e.configs.add(t);
+		}
+		for (const [t, ...e] of this.roots) if (e.length > 0) {
+			const n = this.extensionNameMap.get(t.name);
+			void 0 === n && zt(301, t.name);
+			for (const t of e) n.configs.add(t);
+		}
+		return this._sortedExtensionReps = t, this._sortedExtensionReps;
+	}
+	registerEditor(t) {
+		const e = this.sortedExtensionReps(), n = new AbortController(), i = [() => n.abort()], o = n.signal;
+		for (const n of e) {
+			const e = n.register(t, o);
+			e && i.push(e);
+		}
+		for (const n of e) {
+			const e = n.afterRegistration(t);
+			e && i.push(e);
+		}
+		return mergeRegister(...i);
+	}
+	buildCreateEditorArgs() {
+		const t = {}, e = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), o = {}, s = {}, r = this.sortedExtensionReps();
+		for (const c of r) {
+			const { extension: r } = c;
+			if (void 0 !== r.onError && (t.onError = r.onError), void 0 !== r.disableEvents && (t.disableEvents = r.disableEvents), void 0 !== r.parentEditor && (t.parentEditor = r.parentEditor), void 0 !== r.editable && (t.editable = r.editable), void 0 !== r.namespace && (t.namespace = r.namespace), void 0 !== r.$initialEditorState && (t.$initialEditorState = r.$initialEditorState), r.nodes) for (const t of Dt(r)) {
+				if ("function" != typeof t) {
+					const e = n.get(t.replace);
+					e && zt(302, r.name, t.replace.name, e.extension.name), n.set(t.replace, c);
+				}
+				e.add(t);
+			}
+			if (r.html) {
+				if (r.html.export) for (const [t, e] of r.html.export.entries()) i.set(t, e);
+				r.html.import && Object.assign(o, r.html.import);
+			}
+			r.theme && Lt(s, r.theme);
+		}
+		Object.keys(s).length > 0 && (t.theme = s), e.size && (t.nodes = [...e]);
+		const c = Object.keys(o).length > 0, a = i.size > 0;
+		(c || a) && (t.html = {}, c && (t.html.import = o), a && (t.html.export = i));
+		for (const e of r) e.init(t);
+		return t.onError || (t.onError = re), t;
+	}
+};
+function ue(t, e) {
+	const n = de.fromEditor(t).getExtensionRep(e);
+	return void 0 === n && zt(303, e.name), n.getExtensionDependency();
+}
+function fe(t, e) {
+	const n = de.maybeFromEditor(t);
+	if (!n) return;
+	const i = n.extensionNameMap.get(e);
+	return i ? i.getExtensionDependency() : void 0;
+}
+function le(t, e) {
+	const n = fe(t, e);
+	return void 0 === n && zt(291, e), n;
+}
+const he = /* @__PURE__ */ new Set(), ge = defineExtension({
+	build(t, e, n) {
+		const i = n.getDependency(Kt).output, o = ft({ watchedNodeKeys: /* @__PURE__ */ new Map() }), r = $t(() => {}, () => St(() => {
+			const t = r.peek(), { watchedNodeKeys: e } = o.value;
+			let n, c = !1;
+			i.value.read(() => {
+				if ($getSelection()) for (const [i, o] of e.entries()) {
+					if (0 === o.size) {
+						e.delete(i);
+						continue;
+					}
+					const s = $getNodeByKey(i), r = s && s.isSelected() || !1;
+					c = c || r !== (!!t && t.has(i)), r && (n = n || /* @__PURE__ */ new Set(), n.add(i));
+				}
+			}), !c && n && t && n.size === t.size || (r.value = n);
+		}));
+		return { watchNodeKey: function(t) {
+			const e = mt(() => (r.value || he).has(t)), { watchedNodeKeys: n } = o.peek();
+			let i = n.get(t);
+			const s = void 0 !== i;
+			return i = i || /* @__PURE__ */ new Set(), i.add(e), s || (n.set(t, i), o.value = { watchedNodeKeys: n }), e;
+		} };
+	},
+	dependencies: [Kt],
+	name: "@lexical/extension/NodeSelection"
+}), pe = createCommand("INSERT_HORIZONTAL_RULE_COMMAND");
+var me = class me extends DecoratorNode {
+	static getType() {
+		return "horizontalrule";
+	}
+	static clone(t) {
+		return new me(t.__key);
+	}
+	static importJSON(t) {
+		return xe().updateFromJSON(t);
+	}
+	static importDOM() {
+		return { hr: () => ({
+			conversion: ve,
+			priority: 0
+		}) };
+	}
+	exportDOM() {
+		return { element: document.createElement("hr") };
+	}
+	createDOM(t) {
+		const e = document.createElement("hr");
+		return addClassNamesToElement(e, t.theme.hr), e;
+	}
+	getTextContent() {
+		return "\n";
+	}
+	isInline() {
+		return !1;
+	}
+	updateDOM() {
+		return !1;
+	}
+};
+function ve() {
+	return { node: xe() };
+}
+function xe() {
+	return $create(me);
+}
+function ye(t) {
+	return t instanceof me;
+}
+const Ee = defineExtension({
+	dependencies: [Kt, ge],
+	name: "@lexical/extension/HorizontalRule",
+	nodes: () => [me],
+	register(t, e, n) {
+		const { watchNodeKey: o } = n.getDependency(ge).output, r = ft({ nodeSelections: /* @__PURE__ */ new Map() }), a = t._config.theme.hrSelected ?? "selected";
+		return mergeRegister(t.registerCommand(pe, (t) => {
+			const e = $getSelection();
+			if (!$isRangeSelection(e)) return !1;
+			if (null !== e.focus.getNode()) $insertNodeToNearestRoot(xe());
+			return !0;
+		}, COMMAND_PRIORITY_EDITOR), t.registerCommand(CLICK_COMMAND, (t) => {
+			if (isDOMNode(t.target)) {
+				const e = $getNodeFromDOMNode(t.target);
+				if (ye(e)) return function(t, e = !1) {
+					const n = $getSelection(), i = t.isSelected(), o = t.getKey();
+					let r;
+					e && $isNodeSelection(n) ? r = n : (r = $createNodeSelection(), $setSelection(r)), i ? r.delete(o) : r.add(o);
+				}(e, t.shiftKey), !0;
+			}
+			return !1;
+		}, COMMAND_PRIORITY_LOW), t.registerMutationListener(me, (e, n) => {
+			Y(() => {
+				let n = !1;
+				const { nodeSelections: i } = r.peek();
+				for (const [s, r] of e.entries()) if ("destroyed" === r) i.delete(s), n = !0;
+				else {
+					const e = i.get(s), r = t.getElementByKey(s);
+					e ? e.domNode.value = r : (n = !0, i.set(s, {
+						domNode: ft(r),
+						selectedSignal: o(s)
+					}));
+				}
+				n && (r.value = { nodeSelections: i });
+			});
+		}), St(() => {
+			const t = [];
+			for (const { domNode: e, selectedSignal: n } of r.value.nodeSelections.values()) t.push(St(() => {
+				const t = e.value;
+				if (t) n.value ? addClassNamesToElement(t, a) : removeClassNamesFromElement(t, a);
+			}));
+			return mergeRegister(...t);
+		}));
+	}
+});
+const Se = defineExtension({
+	build: (t, e) => bt({ inheritEditableFromParent: e.inheritEditableFromParent }),
+	config: safeCast({
+		$getParentEditor: function() {
+			const t = $getEditor();
+			return de.fromEditor(t), t;
+		},
+		inheritEditableFromParent: !1
+	}),
+	init: (t, e, n) => {
+		const i = e.$getParentEditor();
+		t.parentEditor = i, t.theme = t.theme || i._config.theme;
+	},
+	name: "@lexical/extension/NestedEditor",
+	register: (t, e, n) => St(() => {
+		const e = t._parentEditor;
+		if (e && n.getOutput().inheritEditableFromParent.value) return t.setEditable(e.isEditable()), e.registerEditableListener(t.setEditable.bind(t));
+	})
+}), be = defineExtension({
+	build: (t, e, n) => bt(e),
+	config: safeCast({
+		disabled: !1,
+		onReposition: void 0
+	}),
+	name: "@lexical/utils/SelectionAlwaysOnDisplay",
+	register: (t, e, n) => {
+		const i = n.getOutput();
+		return St(() => {
+			if (!i.disabled.value) return selectionAlwaysOnDisplay(t, i.onReposition.value);
+		});
+	}
+});
+function we(t) {
+	return t.canBeEmpty();
+}
+function Ne(t, e, n = we) {
+	return mergeRegister(t.registerCommand(KEY_TAB_COMMAND, (e) => {
+		const n = $getSelection();
+		if (!$isRangeSelection(n)) return !1;
+		e.preventDefault();
+		const i = function(t) {
+			if (t.getNodes().filter((t) => $isBlockElementNode(t) && t.canIndent()).length > 0) return !0;
+			const e = t.anchor, n = t.focus, i = n.isBefore(e) ? n : e, s = $getNearestBlockElementAncestorOrThrow(i.getNode());
+			if (s.canIndent()) {
+				const t = s.getKey();
+				let e = $createRangeSelection();
+				if (e.anchor.set(t, 0, "element"), e.focus.set(t, 0, "element"), e = $normalizeSelection__EXPERIMENTAL(e), e.anchor.is(i)) return !0;
+			}
+			return !1;
+		}(n) ? e.shiftKey ? OUTDENT_CONTENT_COMMAND : INDENT_CONTENT_COMMAND : INSERT_TAB_COMMAND;
+		return t.dispatchCommand(i, void 0);
+	}, COMMAND_PRIORITY_EDITOR), t.registerCommand(INDENT_CONTENT_COMMAND, () => {
+		const t = "number" == typeof e ? e : e ? e.peek() : null;
+		if (!$isRangeSelection($getSelection())) return !1;
+		const o = "function" == typeof n ? n : n.peek();
+		return $handleIndentAndOutdent((e) => {
+			if (o(e)) {
+				const n = e.getIndent() + 1;
+				(!t || n < t) && e.setIndent(n);
+			}
+		});
+	}, COMMAND_PRIORITY_CRITICAL));
+}
+const Oe = defineExtension({
+	build: (t, e, n) => bt(e),
+	config: safeCast({
+		$canIndent: we,
+		disabled: !1,
+		maxIndent: null
+	}),
+	name: "@lexical/extension/TabIndentation",
+	register(t, e, n) {
+		const { disabled: i, maxIndent: o, $canIndent: s } = n.getOutput();
+		return St(() => {
+			if (!i.value) return Ne(t, o, s);
+		});
+	}
+});
+//#endregion
+export { xe as $createHorizontalRuleNode, It as $isDecoratorTextNode, ye as $isHorizontalRuleNode, wt as AutoFocusExtension, Rt as ClearEditorExtension, kt as DecoratorTextExtension, Mt as DecoratorTextNode, Kt as EditorStateExtension, Ee as HorizontalRuleExtension, me as HorizontalRuleNode, pe as INSERT_HORIZONTAL_RULE_COMMAND, ne as InitialStateExtension, de as LexicalBuilder, Se as NestedEditorExtension, ge as NodeSelectionExtension, be as SelectionAlwaysOnDisplayExtension, Oe as TabIndentationExtension, _t as applyFormatFromStyle, Pt as applyFormatToDom, Y as batch, oe as buildEditorFromExtensions, mt as computed, configExtension, declarePeerDependency, defineExtension, St as effect, ue as getExtensionDependencyFromEditor, Ct as getKnownTypesAndNodes, fe as getPeerDependencyFromEditor, le as getPeerDependencyFromEditorOrThrow, bt as namedSignals, Ot as registerClearEditor, Ne as registerTabIndentation, safeCast, shallowMergeConfig, ft as signal, nt as untracked, $t as watchedSignal };
+
+//# sourceMappingURL=LexicalExtension.prod-Ug6emhEO.mjs.map