mathjson-tree-builder 0.1.0

package/dist/mathjson-tree-builder.js

@@ -0,0 +1,3720 @@
+//#region node_modules/@lit/reactive-element/css-tag.js
+var e = globalThis, t = e.ShadowRoot && (e.ShadyCSS === void 0 || e.ShadyCSS.nativeShadow) && "adoptedStyleSheets" in Document.prototype && "replace" in CSSStyleSheet.prototype, n = Symbol(), r = /* @__PURE__ */ new WeakMap(), i = class {
+	constructor(e, t, r) {
+		if (this._$cssResult$ = !0, r !== n) throw Error("CSSResult is not constructable. Use `unsafeCSS` or `css` instead.");
+		this.cssText = e, this.t = t;
+	}
+	get styleSheet() {
+		let e = this.o, n = this.t;
+		if (t && e === void 0) {
+			let t = n !== void 0 && n.length === 1;
+			t && (e = r.get(n)), e === void 0 && ((this.o = e = new CSSStyleSheet()).replaceSync(this.cssText), t && r.set(n, e));
+		}
+		return e;
+	}
+	toString() {
+		return this.cssText;
+	}
+}, a = (e) => new i(typeof e == "string" ? e : e + "", void 0, n), o = (e, ...t) => new i(e.length === 1 ? e[0] : t.reduce((t, n, r) => t + ((e) => {
+	if (!0 === e._$cssResult$) return e.cssText;
+	if (typeof e == "number") return e;
+	throw Error("Value passed to 'css' function must be a 'css' function result: " + e + ". Use 'unsafeCSS' to pass non-literal values, but take care to ensure page security.");
+})(n) + e[r + 1], e[0]), e, n), s = (n, r) => {
+	if (t) n.adoptedStyleSheets = r.map((e) => e instanceof CSSStyleSheet ? e : e.styleSheet);
+	else for (let t of r) {
+		let r = document.createElement("style"), i = e.litNonce;
+		i !== void 0 && r.setAttribute("nonce", i), r.textContent = t.cssText, n.appendChild(r);
+	}
+}, c = t ? (e) => e : (e) => e instanceof CSSStyleSheet ? ((e) => {
+	let t = "";
+	for (let n of e.cssRules) t += n.cssText;
+	return a(t);
+})(e) : e, { is: l, defineProperty: u, getOwnPropertyDescriptor: d, getOwnPropertyNames: f, getOwnPropertySymbols: ee, getPrototypeOf: te } = Object, p = globalThis, ne = p.trustedTypes, re = ne ? ne.emptyScript : "", ie = p.reactiveElementPolyfillSupport, m = (e, t) => e, h = {
+	toAttribute(e, t) {
+		switch (t) {
+			case Boolean:
+				e = e ? re : null;
+				break;
+			case Object:
+			case Array: e = e == null ? e : JSON.stringify(e);
+		}
+		return e;
+	},
+	fromAttribute(e, t) {
+		let n = e;
+		switch (t) {
+			case Boolean:
+				n = e !== null;
+				break;
+			case Number:
+				n = e === null ? null : Number(e);
+				break;
+			case Object:
+			case Array: try {
+				n = JSON.parse(e);
+			} catch {
+				n = null;
+			}
+		}
+		return n;
+	}
+}, g = (e, t) => !l(e, t), ae = {
+	attribute: !0,
+	type: String,
+	converter: h,
+	reflect: !1,
+	useDefault: !1,
+	hasChanged: g
+};
+Symbol.metadata ??= Symbol("metadata"), p.litPropertyMetadata ??= /* @__PURE__ */ new WeakMap();
+var _ = class extends HTMLElement {
+	static addInitializer(e) {
+		this._$Ei(), (this.l ??= []).push(e);
+	}
+	static get observedAttributes() {
+		return this.finalize(), this._$Eh && [...this._$Eh.keys()];
+	}
+	static createProperty(e, t = ae) {
+		if (t.state && (t.attribute = !1), this._$Ei(), this.prototype.hasOwnProperty(e) && ((t = Object.create(t)).wrapped = !0), this.elementProperties.set(e, t), !t.noAccessor) {
+			let n = Symbol(), r = this.getPropertyDescriptor(e, n, t);
+			r !== void 0 && u(this.prototype, e, r);
+		}
+	}
+	static getPropertyDescriptor(e, t, n) {
+		let { get: r, set: i } = d(this.prototype, e) ?? {
+			get() {
+				return this[t];
+			},
+			set(e) {
+				this[t] = e;
+			}
+		};
+		return {
+			get: r,
+			set(t) {
+				let a = r?.call(this);
+				i?.call(this, t), this.requestUpdate(e, a, n);
+			},
+			configurable: !0,
+			enumerable: !0
+		};
+	}
+	static getPropertyOptions(e) {
+		return this.elementProperties.get(e) ?? ae;
+	}
+	static _$Ei() {
+		if (this.hasOwnProperty(m("elementProperties"))) return;
+		let e = te(this);
+		e.finalize(), e.l !== void 0 && (this.l = [...e.l]), this.elementProperties = new Map(e.elementProperties);
+	}
+	static finalize() {
+		if (this.hasOwnProperty(m("finalized"))) return;
+		if (this.finalized = !0, this._$Ei(), this.hasOwnProperty(m("properties"))) {
+			let e = this.properties, t = [...f(e), ...ee(e)];
+			for (let n of t) this.createProperty(n, e[n]);
+		}
+		let e = this[Symbol.metadata];
+		if (e !== null) {
+			let t = litPropertyMetadata.get(e);
+			if (t !== void 0) for (let [e, n] of t) this.elementProperties.set(e, n);
+		}
+		this._$Eh = /* @__PURE__ */ new Map();
+		for (let [e, t] of this.elementProperties) {
+			let n = this._$Eu(e, t);
+			n !== void 0 && this._$Eh.set(n, e);
+		}
+		this.elementStyles = this.finalizeStyles(this.styles);
+	}
+	static finalizeStyles(e) {
+		let t = [];
+		if (Array.isArray(e)) {
+			let n = new Set(e.flat(1 / 0).reverse());
+			for (let e of n) t.unshift(c(e));
+		} else e !== void 0 && t.push(c(e));
+		return t;
+	}
+	static _$Eu(e, t) {
+		let n = t.attribute;
+		return !1 === n ? void 0 : typeof n == "string" ? n : typeof e == "string" ? e.toLowerCase() : void 0;
+	}
+	constructor() {
+		super(), this._$Ep = void 0, this.isUpdatePending = !1, this.hasUpdated = !1, this._$Em = null, this._$Ev();
+	}
+	_$Ev() {
+		this._$ES = new Promise((e) => this.enableUpdating = e), this._$AL = /* @__PURE__ */ new Map(), this._$E_(), this.requestUpdate(), this.constructor.l?.forEach((e) => e(this));
+	}
+	addController(e) {
+		(this._$EO ??= /* @__PURE__ */ new Set()).add(e), this.renderRoot !== void 0 && this.isConnected && e.hostConnected?.();
+	}
+	removeController(e) {
+		this._$EO?.delete(e);
+	}
+	_$E_() {
+		let e = /* @__PURE__ */ new Map(), t = this.constructor.elementProperties;
+		for (let n of t.keys()) this.hasOwnProperty(n) && (e.set(n, this[n]), delete this[n]);
+		e.size > 0 && (this._$Ep = e);
+	}
+	createRenderRoot() {
+		let e = this.shadowRoot ?? this.attachShadow(this.constructor.shadowRootOptions);
+		return s(e, this.constructor.elementStyles), e;
+	}
+	connectedCallback() {
+		this.renderRoot ??= this.createRenderRoot(), this.enableUpdating(!0), this._$EO?.forEach((e) => e.hostConnected?.());
+	}
+	enableUpdating(e) {}
+	disconnectedCallback() {
+		this._$EO?.forEach((e) => e.hostDisconnected?.());
+	}
+	attributeChangedCallback(e, t, n) {
+		this._$AK(e, n);
+	}
+	_$ET(e, t) {
+		let n = this.constructor.elementProperties.get(e), r = this.constructor._$Eu(e, n);
+		if (r !== void 0 && !0 === n.reflect) {
+			let i = (n.converter?.toAttribute === void 0 ? h : n.converter).toAttribute(t, n.type);
+			this._$Em = e, i == null ? this.removeAttribute(r) : this.setAttribute(r, i), this._$Em = null;
+		}
+	}
+	_$AK(e, t) {
+		let n = this.constructor, r = n._$Eh.get(e);
+		if (r !== void 0 && this._$Em !== r) {
+			let e = n.getPropertyOptions(r), i = typeof e.converter == "function" ? { fromAttribute: e.converter } : e.converter?.fromAttribute === void 0 ? h : e.converter;
+			this._$Em = r;
+			let a = i.fromAttribute(t, e.type);
+			this[r] = a ?? this._$Ej?.get(r) ?? a, this._$Em = null;
+		}
+	}
+	requestUpdate(e, t, n, r = !1, i) {
+		if (e !== void 0) {
+			let a = this.constructor;
+			if (!1 === r && (i = this[e]), n ??= a.getPropertyOptions(e), !((n.hasChanged ?? g)(i, t) || n.useDefault && n.reflect && i === this._$Ej?.get(e) && !this.hasAttribute(a._$Eu(e, n)))) return;
+			this.C(e, t, n);
+		}
+		!1 === this.isUpdatePending && (this._$ES = this._$EP());
+	}
+	C(e, t, { useDefault: n, reflect: r, wrapped: i }, a) {
+		n && !(this._$Ej ??= /* @__PURE__ */ new Map()).has(e) && (this._$Ej.set(e, a ?? t ?? this[e]), !0 !== i || a !== void 0) || (this._$AL.has(e) || (this.hasUpdated || n || (t = void 0), this._$AL.set(e, t)), !0 === r && this._$Em !== e && (this._$Eq ??= /* @__PURE__ */ new Set()).add(e));
+	}
+	async _$EP() {
+		this.isUpdatePending = !0;
+		try {
+			await this._$ES;
+		} catch (e) {
+			Promise.reject(e);
+		}
+		let e = this.scheduleUpdate();
+		return e != null && await e, !this.isUpdatePending;
+	}
+	scheduleUpdate() {
+		return this.performUpdate();
+	}
+	performUpdate() {
+		if (!this.isUpdatePending) return;
+		if (!this.hasUpdated) {
+			if (this.renderRoot ??= this.createRenderRoot(), this._$Ep) {
+				for (let [e, t] of this._$Ep) this[e] = t;
+				this._$Ep = void 0;
+			}
+			let e = this.constructor.elementProperties;
+			if (e.size > 0) for (let [t, n] of e) {
+				let { wrapped: e } = n, r = this[t];
+				!0 !== e || this._$AL.has(t) || r === void 0 || this.C(t, void 0, n, r);
+			}
+		}
+		let e = !1, t = this._$AL;
+		try {
+			e = this.shouldUpdate(t), e ? (this.willUpdate(t), this._$EO?.forEach((e) => e.hostUpdate?.()), this.update(t)) : this._$EM();
+		} catch (t) {
+			throw e = !1, this._$EM(), t;
+		}
+		e && this._$AE(t);
+	}
+	willUpdate(e) {}
+	_$AE(e) {
+		this._$EO?.forEach((e) => e.hostUpdated?.()), this.hasUpdated || (this.hasUpdated = !0, this.firstUpdated(e)), this.updated(e);
+	}
+	_$EM() {
+		this._$AL = /* @__PURE__ */ new Map(), this.isUpdatePending = !1;
+	}
+	get updateComplete() {
+		return this.getUpdateComplete();
+	}
+	getUpdateComplete() {
+		return this._$ES;
+	}
+	shouldUpdate(e) {
+		return !0;
+	}
+	update(e) {
+		this._$Eq &&= this._$Eq.forEach((e) => this._$ET(e, this[e])), this._$EM();
+	}
+	updated(e) {}
+	firstUpdated(e) {}
+};
+_.elementStyles = [], _.shadowRootOptions = { mode: "open" }, _[m("elementProperties")] = /* @__PURE__ */ new Map(), _[m("finalized")] = /* @__PURE__ */ new Map(), ie?.({ ReactiveElement: _ }), (p.reactiveElementVersions ??= []).push("2.1.2");
+//#endregion
+//#region node_modules/lit-html/lit-html.js
+var v = globalThis, oe = (e) => e, y = v.trustedTypes, se = y ? y.createPolicy("lit-html", { createHTML: (e) => e }) : void 0, ce = "$lit$", b = `lit$${Math.random().toFixed(9).slice(2)}$`, le = "?" + b, ue = `<${le}>`, x = document, S = () => x.createComment(""), C = (e) => e === null || typeof e != "object" && typeof e != "function", w = Array.isArray, de = (e) => w(e) || typeof e?.[Symbol.iterator] == "function", T = "[ 	\n\f\r]", E = /<(?:(!--|\/[^a-zA-Z])|(\/?[a-zA-Z][^>\s]*)|(\/?$))/g, fe = /-->/g, pe = />/g, D = RegExp(`>|${T}(?:([^\\s"'>=/]+)(${T}*=${T}*(?:[^ \t\n\f\r"'\`<>=]|("|')|))|$)`, "g"), me = /'/g, he = /"/g, ge = /^(?:script|style|textarea|title)$/i, O = ((e) => (t, ...n) => ({
+	_$litType$: e,
+	strings: t,
+	values: n
+}))(1), k = Symbol.for("lit-noChange"), A = Symbol.for("lit-nothing"), _e = /* @__PURE__ */ new WeakMap(), j = x.createTreeWalker(x, 129);
+function ve(e, t) {
+	if (!w(e) || !e.hasOwnProperty("raw")) throw Error("invalid template strings array");
+	return se === void 0 ? t : se.createHTML(t);
+}
+var ye = (e, t) => {
+	let n = e.length - 1, r = [], i, a = t === 2 ? "<svg>" : t === 3 ? "<math>" : "", o = E;
+	for (let t = 0; t < n; t++) {
+		let n = e[t], s, c, l = -1, u = 0;
+		for (; u < n.length && (o.lastIndex = u, c = o.exec(n), c !== null);) u = o.lastIndex, o === E ? c[1] === "!--" ? o = fe : c[1] === void 0 ? c[2] === void 0 ? c[3] !== void 0 && (o = D) : (ge.test(c[2]) && (i = RegExp("</" + c[2], "g")), o = D) : o = pe : o === D ? c[0] === ">" ? (o = i ?? E, l = -1) : c[1] === void 0 ? l = -2 : (l = o.lastIndex - c[2].length, s = c[1], o = c[3] === void 0 ? D : c[3] === "\"" ? he : me) : o === he || o === me ? o = D : o === fe || o === pe ? o = E : (o = D, i = void 0);
+		let d = o === D && e[t + 1].startsWith("/>") ? " " : "";
+		a += o === E ? n + ue : l >= 0 ? (r.push(s), n.slice(0, l) + ce + n.slice(l) + b + d) : n + b + (l === -2 ? t : d);
+	}
+	return [ve(e, a + (e[n] || "<?>") + (t === 2 ? "</svg>" : t === 3 ? "</math>" : "")), r];
+}, M = class e {
+	constructor({ strings: t, _$litType$: n }, r) {
+		let i;
+		this.parts = [];
+		let a = 0, o = 0, s = t.length - 1, c = this.parts, [l, u] = ye(t, n);
+		if (this.el = e.createElement(l, r), j.currentNode = this.el.content, n === 2 || n === 3) {
+			let e = this.el.content.firstChild;
+			e.replaceWith(...e.childNodes);
+		}
+		for (; (i = j.nextNode()) !== null && c.length < s;) {
+			if (i.nodeType === 1) {
+				if (i.hasAttributes()) for (let e of i.getAttributeNames()) if (e.endsWith(ce)) {
+					let t = u[o++], n = i.getAttribute(e).split(b), r = /([.?@])?(.*)/.exec(t);
+					c.push({
+						type: 1,
+						index: a,
+						name: r[2],
+						strings: n,
+						ctor: r[1] === "." ? xe : r[1] === "?" ? Se : r[1] === "@" ? Ce : F
+					}), i.removeAttribute(e);
+				} else e.startsWith(b) && (c.push({
+					type: 6,
+					index: a
+				}), i.removeAttribute(e));
+				if (ge.test(i.tagName)) {
+					let e = i.textContent.split(b), t = e.length - 1;
+					if (t > 0) {
+						i.textContent = y ? y.emptyScript : "";
+						for (let n = 0; n < t; n++) i.append(e[n], S()), j.nextNode(), c.push({
+							type: 2,
+							index: ++a
+						});
+						i.append(e[t], S());
+					}
+				}
+			} else if (i.nodeType === 8) {
+				if (i.data === le) c.push({
+					type: 2,
+					index: a
+				});
+				else {
+					let e = -1;
+					for (; (e = i.data.indexOf(b, e + 1)) !== -1;) c.push({
+						type: 7,
+						index: a
+					}), e += b.length - 1;
+				}
+			}
+			a++;
+		}
+	}
+	static createElement(e, t) {
+		let n = x.createElement("template");
+		return n.innerHTML = e, n;
+	}
+};
+function N(e, t, n = e, r) {
+	if (t === k) return t;
+	let i = r === void 0 ? n._$Cl : n._$Co?.[r], a = C(t) ? void 0 : t._$litDirective$;
+	return i?.constructor !== a && (i?._$AO?.(!1), a === void 0 ? i = void 0 : (i = new a(e), i._$AT(e, n, r)), r === void 0 ? n._$Cl = i : (n._$Co ??= [])[r] = i), i !== void 0 && (t = N(e, i._$AS(e, t.values), i, r)), t;
+}
+var be = class {
+	constructor(e, t) {
+		this._$AV = [], this._$AN = void 0, this._$AD = e, this._$AM = t;
+	}
+	get parentNode() {
+		return this._$AM.parentNode;
+	}
+	get _$AU() {
+		return this._$AM._$AU;
+	}
+	u(e) {
+		let { el: { content: t }, parts: n } = this._$AD, r = (e?.creationScope ?? x).importNode(t, !0);
+		j.currentNode = r;
+		let i = j.nextNode(), a = 0, o = 0, s = n[0];
+		for (; s !== void 0;) {
+			if (a === s.index) {
+				let t;
+				s.type === 2 ? t = new P(i, i.nextSibling, this, e) : s.type === 1 ? t = new s.ctor(i, s.name, s.strings, this, e) : s.type === 6 && (t = new we(i, this, e)), this._$AV.push(t), s = n[++o];
+			}
+			a !== s?.index && (i = j.nextNode(), a++);
+		}
+		return j.currentNode = x, r;
+	}
+	p(e) {
+		let t = 0;
+		for (let n of this._$AV) n !== void 0 && (n.strings === void 0 ? n._$AI(e[t]) : (n._$AI(e, n, t), t += n.strings.length - 2)), t++;
+	}
+}, P = class e {
+	get _$AU() {
+		return this._$AM?._$AU ?? this._$Cv;
+	}
+	constructor(e, t, n, r) {
+		this.type = 2, this._$AH = A, this._$AN = void 0, this._$AA = e, this._$AB = t, this._$AM = n, this.options = r, this._$Cv = r?.isConnected ?? !0;
+	}
+	get parentNode() {
+		let e = this._$AA.parentNode, t = this._$AM;
+		return t !== void 0 && e?.nodeType === 11 && (e = t.parentNode), e;
+	}
+	get startNode() {
+		return this._$AA;
+	}
+	get endNode() {
+		return this._$AB;
+	}
+	_$AI(e, t = this) {
+		e = N(this, e, t), C(e) ? e === A || e == null || e === "" ? (this._$AH !== A && this._$AR(), this._$AH = A) : e !== this._$AH && e !== k && this._(e) : e._$litType$ === void 0 ? e.nodeType === void 0 ? de(e) ? this.k(e) : this._(e) : this.T(e) : this.$(e);
+	}
+	O(e) {
+		return this._$AA.parentNode.insertBefore(e, this._$AB);
+	}
+	T(e) {
+		this._$AH !== e && (this._$AR(), this._$AH = this.O(e));
+	}
+	_(e) {
+		this._$AH !== A && C(this._$AH) ? this._$AA.nextSibling.data = e : this.T(x.createTextNode(e)), this._$AH = e;
+	}
+	$(e) {
+		let { values: t, _$litType$: n } = e, r = typeof n == "number" ? this._$AC(e) : (n.el === void 0 && (n.el = M.createElement(ve(n.h, n.h[0]), this.options)), n);
+		if (this._$AH?._$AD === r) this._$AH.p(t);
+		else {
+			let e = new be(r, this), n = e.u(this.options);
+			e.p(t), this.T(n), this._$AH = e;
+		}
+	}
+	_$AC(e) {
+		let t = _e.get(e.strings);
+		return t === void 0 && _e.set(e.strings, t = new M(e)), t;
+	}
+	k(t) {
+		w(this._$AH) || (this._$AH = [], this._$AR());
+		let n = this._$AH, r, i = 0;
+		for (let a of t) i === n.length ? n.push(r = new e(this.O(S()), this.O(S()), this, this.options)) : r = n[i], r._$AI(a), i++;
+		i < n.length && (this._$AR(r && r._$AB.nextSibling, i), n.length = i);
+	}
+	_$AR(e = this._$AA.nextSibling, t) {
+		for (this._$AP?.(!1, !0, t); e !== this._$AB;) {
+			let t = oe(e).nextSibling;
+			oe(e).remove(), e = t;
+		}
+	}
+	setConnected(e) {
+		this._$AM === void 0 && (this._$Cv = e, this._$AP?.(e));
+	}
+}, F = class {
+	get tagName() {
+		return this.element.tagName;
+	}
+	get _$AU() {
+		return this._$AM._$AU;
+	}
+	constructor(e, t, n, r, i) {
+		this.type = 1, this._$AH = A, this._$AN = void 0, this.element = e, this.name = t, this._$AM = r, this.options = i, n.length > 2 || n[0] !== "" || n[1] !== "" ? (this._$AH = Array(n.length - 1).fill(/* @__PURE__ */ new String()), this.strings = n) : this._$AH = A;
+	}
+	_$AI(e, t = this, n, r) {
+		let i = this.strings, a = !1;
+		if (i === void 0) e = N(this, e, t, 0), a = !C(e) || e !== this._$AH && e !== k, a && (this._$AH = e);
+		else {
+			let r = e, o, s;
+			for (e = i[0], o = 0; o < i.length - 1; o++) s = N(this, r[n + o], t, o), s === k && (s = this._$AH[o]), a ||= !C(s) || s !== this._$AH[o], s === A ? e = A : e !== A && (e += (s ?? "") + i[o + 1]), this._$AH[o] = s;
+		}
+		a && !r && this.j(e);
+	}
+	j(e) {
+		e === A ? this.element.removeAttribute(this.name) : this.element.setAttribute(this.name, e ?? "");
+	}
+}, xe = class extends F {
+	constructor() {
+		super(...arguments), this.type = 3;
+	}
+	j(e) {
+		this.element[this.name] = e === A ? void 0 : e;
+	}
+}, Se = class extends F {
+	constructor() {
+		super(...arguments), this.type = 4;
+	}
+	j(e) {
+		this.element.toggleAttribute(this.name, !!e && e !== A);
+	}
+}, Ce = class extends F {
+	constructor(e, t, n, r, i) {
+		super(e, t, n, r, i), this.type = 5;
+	}
+	_$AI(e, t = this) {
+		if ((e = N(this, e, t, 0) ?? A) === k) return;
+		let n = this._$AH, r = e === A && n !== A || e.capture !== n.capture || e.once !== n.once || e.passive !== n.passive, i = e !== A && (n === A || r);
+		r && this.element.removeEventListener(this.name, this, n), i && this.element.addEventListener(this.name, this, e), this._$AH = e;
+	}
+	handleEvent(e) {
+		typeof this._$AH == "function" ? this._$AH.call(this.options?.host ?? this.element, e) : this._$AH.handleEvent(e);
+	}
+}, we = class {
+	constructor(e, t, n) {
+		this.element = e, this.type = 6, this._$AN = void 0, this._$AM = t, this.options = n;
+	}
+	get _$AU() {
+		return this._$AM._$AU;
+	}
+	_$AI(e) {
+		N(this, e);
+	}
+}, Te = v.litHtmlPolyfillSupport;
+Te?.(M, P), (v.litHtmlVersions ??= []).push("3.3.3");
+var Ee = (e, t, n) => {
+	let r = n?.renderBefore ?? t, i = r._$litPart$;
+	if (i === void 0) {
+		let e = n?.renderBefore ?? null;
+		r._$litPart$ = i = new P(t.insertBefore(S(), e), e, void 0, n ?? {});
+	}
+	return i._$AI(e), i;
+}, I = globalThis, L = class extends _ {
+	constructor() {
+		super(...arguments), this.renderOptions = { host: this }, this._$Do = void 0;
+	}
+	createRenderRoot() {
+		let e = super.createRenderRoot();
+		return this.renderOptions.renderBefore ??= e.firstChild, e;
+	}
+	update(e) {
+		let t = this.render();
+		this.hasUpdated || (this.renderOptions.isConnected = this.isConnected), super.update(e), this._$Do = Ee(t, this.renderRoot, this.renderOptions);
+	}
+	connectedCallback() {
+		super.connectedCallback(), this._$Do?.setConnected(!0);
+	}
+	disconnectedCallback() {
+		super.disconnectedCallback(), this._$Do?.setConnected(!1);
+	}
+	render() {
+		return k;
+	}
+};
+L._$litElement$ = !0, L.finalized = !0, I.litElementHydrateSupport?.({ LitElement: L });
+var De = I.litElementPolyfillSupport;
+De?.({ LitElement: L }), (I.litElementVersions ??= []).push("4.2.2");
+//#endregion
+//#region node_modules/@lit/reactive-element/decorators/property.js
+var Oe = {
+	attribute: !0,
+	type: String,
+	converter: h,
+	reflect: !1,
+	hasChanged: g
+}, ke = (e = Oe, t, n) => {
+	let { kind: r, metadata: i } = n, a = globalThis.litPropertyMetadata.get(i);
+	if (a === void 0 && globalThis.litPropertyMetadata.set(i, a = /* @__PURE__ */ new Map()), r === "setter" && ((e = Object.create(e)).wrapped = !0), a.set(n.name, e), r === "accessor") {
+		let { name: r } = n;
+		return {
+			set(n) {
+				let i = t.get.call(this);
+				t.set.call(this, n), this.requestUpdate(r, i, e, !0, n);
+			},
+			init(t) {
+				return t !== void 0 && this.C(r, void 0, e, t), t;
+			}
+		};
+	}
+	if (r === "setter") {
+		let { name: r } = n;
+		return function(n) {
+			let i = this[r];
+			t.call(this, n), this.requestUpdate(r, i, e, !0, n);
+		};
+	}
+	throw Error("Unsupported decorator location: " + r);
+};
+function R(e) {
+	return (t, n) => typeof n == "object" ? ke(e, t, n) : ((e, t, n) => {
+		let r = t.hasOwnProperty(n);
+		return t.constructor.createProperty(n, e), r ? Object.getOwnPropertyDescriptor(t, n) : void 0;
+	})(e, t, n);
+}
+//#endregion
+//#region node_modules/@lit/reactive-element/decorators/state.js
+function z(e) {
+	return R({
+		...e,
+		state: !0,
+		attribute: !1
+	});
+}
+//#endregion
+//#region src/types.ts
+function B(e) {
+	return Array.isArray(e) && typeof e[0] == "string";
+}
+function V(e) {
+	return typeof e == "number" || typeof e == "boolean" || typeof e == "string" || Array.isArray(e) && e.every(V);
+}
+//#endregion
+//#region src/data-model/path.ts
+function H(e, t) {
+	let n = e;
+	for (let e of t) {
+		if (!Array.isArray(n)) throw Error(`getAtPath: cannot descend into a non-array node at index ${e}`);
+		let t = n[e];
+		if (t === void 0) throw Error(`getAtPath: no element at index ${e}`);
+		n = t;
+	}
+	return n;
+}
+function U(e, t, n) {
+	if (t.length === 0) return n;
+	let r = t[0], i = t.slice(1);
+	if (!Array.isArray(e)) throw Error(`setAtPath: cannot descend into a non-array node at index ${r}`);
+	let a = e.slice();
+	return a[r] = U(a[r] ?? 0, i, n), a;
+}
+function W(e, t) {
+	return [...e, t];
+}
+function Ae(e, t) {
+	if (t <= 0) throw Error("withArgRemoved: argIndex must be >= 1");
+	return e.filter((e, n) => n !== t);
+}
+function je(e, t, n, r = []) {
+	return U(e, t, [
+		n,
+		H(e, t),
+		...r
+	]);
+}
+function Me(e, t, n, r = !1) {
+	let i = H(e, t);
+	if (!B(i)) throw Error("swapOperator: node at path is not a compound expression");
+	let a = i.slice(1);
+	return r && a.length >= 2 && ([a[0], a[1]] = [a[1], a[0]]), U(e, t, [n, ...a]);
+}
+//#endregion
+//#region src/data-model/symbols.ts
+function G(e, t) {
+	return e.find((e) => e.id === t);
+}
+function Ne(e, t, n) {
+	let r = t.trim().toLowerCase();
+	return e.filter((e) => !r || e.label.toLowerCase().includes(r) || e.id.toLowerCase().includes(r)).slice().sort((e, t) => {
+		if (n) {
+			let r = e.type === n ? 0 : 1, i = t.type === n ? 0 : 1;
+			if (r !== i) return r - i;
+		}
+		return e.label.localeCompare(t.label);
+	});
+}
+//#endregion
+//#region src/data-model/classify.ts
+function Pe(e, t) {
+	return Array.isArray(e) ? "function" : typeof e == "number" ? "number" : typeof e == "boolean" ? "boolean" : G(t, e) ? "symbol" : "text";
+}
+//#endregion
+//#region src/registry/constructs.generated.ts
+var Fe = {
+	arithmetic: "Arithmetic",
+	array_arithmetic: "Array Arithmetic",
+	boolean_logic: "Boolean Logic",
+	collection: "Collections",
+	combinatorics: "Combinatorics",
+	comparison: "Comparisons",
+	constants: "Constants",
+	control_flow: "Control Flow",
+	core: "Core",
+	datetime: "Date & Time",
+	functional: "Functional",
+	number_theory: "Number Theory",
+	special_function: "Special Functions",
+	statistics: "Statistics",
+	string: "Strings",
+	trigonometric: "Trigonometric"
+}, K = [
+	{
+		name: "Abs",
+		category: "arithmetic"
+	},
+	{
+		name: "Add",
+		category: "arithmetic"
+	},
+	{
+		name: "Average",
+		category: "arithmetic"
+	},
+	{
+		name: "Ceil",
+		category: "arithmetic"
+	},
+	{
+		name: "Clamp",
+		category: "arithmetic"
+	},
+	{
+		name: "Denominator",
+		category: "arithmetic"
+	},
+	{
+		name: "Divide",
+		category: "arithmetic"
+	},
+	{
+		name: "Equal",
+		category: "arithmetic"
+	},
+	{
+		name: "Exp",
+		category: "arithmetic"
+	},
+	{
+		name: "Float",
+		category: "arithmetic"
+	},
+	{
+		name: "Floor",
+		category: "arithmetic"
+	},
+	{
+		name: "If",
+		category: "arithmetic"
+	},
+	{
+		name: "Int",
+		category: "arithmetic"
+	},
+	{
+		name: "IsFalse",
+		category: "arithmetic"
+	},
+	{
+		name: "IsTrue",
+		category: "arithmetic"
+	},
+	{
+		name: "Lb",
+		category: "arithmetic"
+	},
+	{
+		name: "Lg",
+		category: "arithmetic"
+	},
+	{
+		name: "List",
+		category: "arithmetic"
+	},
+	{
+		name: "Ln",
+		category: "arithmetic"
+	},
+	{
+		name: "Log",
+		category: "arithmetic"
+	},
+	{
+		name: "Log10",
+		category: "arithmetic"
+	},
+	{
+		name: "Log2",
+		category: "arithmetic"
+	},
+	{
+		name: "LogOnePlus",
+		category: "arithmetic"
+	},
+	{
+		name: "Max",
+		category: "arithmetic"
+	},
+	{
+		name: "Mean",
+		category: "arithmetic"
+	},
+	{
+		name: "Median",
+		category: "arithmetic"
+	},
+	{
+		name: "Min",
+		category: "arithmetic"
+	},
+	{
+		name: "Multiply",
+		category: "arithmetic"
+	},
+	{
+		name: "Negate",
+		category: "arithmetic"
+	},
+	{
+		name: "NotEqual",
+		category: "arithmetic"
+	},
+	{
+		name: "Numerator",
+		category: "arithmetic"
+	},
+	{
+		name: "Power",
+		category: "arithmetic"
+	},
+	{
+		name: "Product",
+		category: "arithmetic"
+	},
+	{
+		name: "Rational",
+		category: "arithmetic"
+	},
+	{
+		name: "Root",
+		category: "arithmetic"
+	},
+	{
+		name: "Round",
+		category: "arithmetic"
+	},
+	{
+		name: "Sqrt",
+		category: "arithmetic"
+	},
+	{
+		name: "Square",
+		category: "arithmetic"
+	},
+	{
+		name: "StrictEqual",
+		category: "arithmetic"
+	},
+	{
+		name: "Subtract",
+		category: "arithmetic"
+	},
+	{
+		name: "Sum",
+		category: "arithmetic"
+	},
+	{
+		name: "AddArray",
+		category: "array_arithmetic"
+	},
+	{
+		name: "AddScalar",
+		category: "array_arithmetic"
+	},
+	{
+		name: "AtIndex",
+		category: "array_arithmetic"
+	},
+	{
+		name: "CumulativeProduct",
+		category: "array_arithmetic"
+	},
+	{
+		name: "CumulativeSum",
+		category: "array_arithmetic"
+	},
+	{
+		name: "FindIntervalIndex",
+		category: "array_arithmetic"
+	},
+	{
+		name: "GenerateRange",
+		category: "array_arithmetic"
+	},
+	{
+		name: "Interp",
+		category: "array_arithmetic"
+	},
+	{
+		name: "MultiplyByArray",
+		category: "array_arithmetic"
+	},
+	{
+		name: "MultiplyByScalar",
+		category: "array_arithmetic"
+	},
+	{
+		name: "Slice",
+		category: "array_arithmetic"
+	},
+	{
+		name: "SubtractArray",
+		category: "array_arithmetic"
+	},
+	{
+		name: "SubtractScalar",
+		category: "array_arithmetic"
+	},
+	{
+		name: "TrapezoidalIntegrate",
+		category: "array_arithmetic"
+	},
+	{
+		name: "Equivalent",
+		category: "boolean_logic"
+	},
+	{
+		name: "Implies",
+		category: "boolean_logic"
+	},
+	{
+		name: "Nand",
+		category: "boolean_logic"
+	},
+	{
+		name: "Nor",
+		category: "boolean_logic"
+	},
+	{
+		name: "Xor",
+		category: "boolean_logic"
+	},
+	{
+		name: "All",
+		category: "collection"
+	},
+	{
+		name: "Any",
+		category: "collection"
+	},
+	{
+		name: "Append",
+		category: "collection"
+	},
+	{
+		name: "Appended",
+		category: "collection"
+	},
+	{
+		name: "ArgMax",
+		category: "collection"
+	},
+	{
+		name: "ArgMin",
+		category: "collection"
+	},
+	{
+		name: "Array",
+		category: "collection"
+	},
+	{
+		name: "At",
+		category: "collection"
+	},
+	{
+		name: "Chunk",
+		category: "collection"
+	},
+	{
+		name: "ChunkBy",
+		category: "collection"
+	},
+	{
+		name: "Contains",
+		category: "collection"
+	},
+	{
+		name: "ContainsAllOf",
+		category: "collection"
+	},
+	{
+		name: "ContainsAnyOf",
+		category: "collection"
+	},
+	{
+		name: "ContainsNoneOf",
+		category: "collection"
+	},
+	{
+		name: "Contains_all_of",
+		category: "collection"
+	},
+	{
+		name: "Contains_any_of",
+		category: "collection"
+	},
+	{
+		name: "Contains_none_of",
+		category: "collection"
+	},
+	{
+		name: "Count",
+		category: "collection"
+	},
+	{
+		name: "CountIf",
+		category: "collection"
+	},
+	{
+		name: "Dedup",
+		category: "collection"
+	},
+	{
+		name: "DeleteAt",
+		category: "collection"
+	},
+	{
+		name: "Differences",
+		category: "collection"
+	},
+	{
+		name: "Drop",
+		category: "collection"
+	},
+	{
+		name: "DropWhile",
+		category: "collection"
+	},
+	{
+		name: "Element",
+		category: "collection"
+	},
+	{
+		name: "Find",
+		category: "collection"
+	},
+	{
+		name: "First",
+		category: "collection"
+	},
+	{
+		name: "FlatMap",
+		category: "collection"
+	},
+	{
+		name: "GroupBy",
+		category: "collection"
+	},
+	{
+		name: "HasMatchingSublist",
+		category: "collection"
+	},
+	{
+		name: "In",
+		category: "collection"
+	},
+	{
+		name: "IndexOf",
+		category: "collection"
+	},
+	{
+		name: "IndexWhere",
+		category: "collection"
+	},
+	{
+		name: "Insert",
+		category: "collection"
+	},
+	{
+		name: "Intersection",
+		category: "collection"
+	},
+	{
+		name: "Interval",
+		category: "collection"
+	},
+	{
+		name: "IsEmpty",
+		category: "collection"
+	},
+	{
+		name: "Join",
+		category: "collection"
+	},
+	{
+		name: "Last",
+		category: "collection"
+	},
+	{
+		name: "Length",
+		category: "collection"
+	},
+	{
+		name: "MaxBy",
+		category: "collection"
+	},
+	{
+		name: "MinBy",
+		category: "collection"
+	},
+	{
+		name: "Most",
+		category: "collection"
+	},
+	{
+		name: "NotElement",
+		category: "collection"
+	},
+	{
+		name: "NotIn",
+		category: "collection"
+	},
+	{
+		name: "NotSubset",
+		category: "collection"
+	},
+	{
+		name: "NotSuperset",
+		category: "collection"
+	},
+	{
+		name: "Not_in",
+		category: "collection"
+	},
+	{
+		name: "Open",
+		category: "collection"
+	},
+	{
+		name: "Ordering",
+		category: "collection"
+	},
+	{
+		name: "Partition",
+		category: "collection"
+	},
+	{
+		name: "Position",
+		category: "collection"
+	},
+	{
+		name: "Range",
+		category: "collection"
+	},
+	{
+		name: "ReplaceAt",
+		category: "collection"
+	},
+	{
+		name: "Rest",
+		category: "collection"
+	},
+	{
+		name: "Reverse",
+		category: "collection"
+	},
+	{
+		name: "RotateLeft",
+		category: "collection"
+	},
+	{
+		name: "RotateRight",
+		category: "collection"
+	},
+	{
+		name: "Scan",
+		category: "collection"
+	},
+	{
+		name: "Second",
+		category: "collection"
+	},
+	{
+		name: "SetMinus",
+		category: "collection"
+	},
+	{
+		name: "Sort",
+		category: "collection"
+	},
+	{
+		name: "Subset",
+		category: "collection"
+	},
+	{
+		name: "SubsetEqual",
+		category: "collection"
+	},
+	{
+		name: "Superset",
+		category: "collection"
+	},
+	{
+		name: "SupersetEqual",
+		category: "collection"
+	},
+	{
+		name: "SymmetricDifference",
+		category: "collection"
+	},
+	{
+		name: "Take",
+		category: "collection"
+	},
+	{
+		name: "TakeWhile",
+		category: "collection"
+	},
+	{
+		name: "Tally",
+		category: "collection"
+	},
+	{
+		name: "Third",
+		category: "collection"
+	},
+	{
+		name: "Union",
+		category: "collection"
+	},
+	{
+		name: "Unique",
+		category: "collection"
+	},
+	{
+		name: "Zip",
+		category: "collection"
+	},
+	{
+		name: "BellNumber",
+		category: "combinatorics"
+	},
+	{
+		name: "CartesianProduct",
+		category: "combinatorics"
+	},
+	{
+		name: "Choose",
+		category: "combinatorics"
+	},
+	{
+		name: "Combinations",
+		category: "combinatorics"
+	},
+	{
+		name: "Fibonacci",
+		category: "combinatorics"
+	},
+	{
+		name: "Multinomial",
+		category: "combinatorics"
+	},
+	{
+		name: "Permutations",
+		category: "combinatorics"
+	},
+	{
+		name: "PowerSet",
+		category: "combinatorics"
+	},
+	{
+		name: "Subfactorial",
+		category: "combinatorics"
+	},
+	{
+		name: "And",
+		category: "comparison"
+	},
+	{
+		name: "Congruent",
+		category: "comparison"
+	},
+	{
+		name: "Greater",
+		category: "comparison"
+	},
+	{
+		name: "GreaterEqual",
+		category: "comparison"
+	},
+	{
+		name: "IdenticallyEqual",
+		category: "comparison"
+	},
+	{
+		name: "IsDefined",
+		category: "comparison"
+	},
+	{
+		name: "IsUndefined",
+		category: "comparison"
+	},
+	{
+		name: "Less",
+		category: "comparison"
+	},
+	{
+		name: "LessEqual",
+		category: "comparison"
+	},
+	{
+		name: "Not",
+		category: "comparison"
+	},
+	{
+		name: "Or",
+		category: "comparison"
+	},
+	{
+		name: "CatalanConstant",
+		category: "constants"
+	},
+	{
+		name: "Degrees",
+		category: "constants"
+	},
+	{
+		name: "EulerGamma",
+		category: "constants"
+	},
+	{
+		name: "ExponentialE",
+		category: "constants"
+	},
+	{
+		name: "GoldenRatio",
+		category: "constants"
+	},
+	{
+		name: "MachineEpsilon",
+		category: "constants"
+	},
+	{
+		name: "Constants",
+		category: "control_flow"
+	},
+	{
+		name: "Function",
+		category: "control_flow"
+	},
+	{
+		name: "StrictSwitch",
+		category: "control_flow"
+	},
+	{
+		name: "Switch",
+		category: "control_flow"
+	},
+	{
+		name: "Variable",
+		category: "control_flow"
+	},
+	{
+		name: "Which",
+		category: "control_flow"
+	},
+	{
+		name: "Head",
+		category: "core"
+	},
+	{
+		name: "Hold",
+		category: "core"
+	},
+	{
+		name: "Identity",
+		category: "core"
+	},
+	{
+		name: "IsSame",
+		category: "core"
+	},
+	{
+		name: "Same",
+		category: "core"
+	},
+	{
+		name: "Tail",
+		category: "core"
+	},
+	{
+		name: "Type",
+		category: "core"
+	},
+	{
+		name: "Now",
+		category: "datetime"
+	},
+	{
+		name: "Strftime",
+		category: "datetime"
+	},
+	{
+		name: "Strptime",
+		category: "datetime"
+	},
+	{
+		name: "TimeDeltaDays",
+		category: "datetime"
+	},
+	{
+		name: "TimeDeltaHours",
+		category: "datetime"
+	},
+	{
+		name: "TimeDeltaMinutes",
+		category: "datetime"
+	},
+	{
+		name: "TimeDeltaWeeks",
+		category: "datetime"
+	},
+	{
+		name: "Today",
+		category: "datetime"
+	},
+	{
+		name: "Filter",
+		category: "functional"
+	},
+	{
+		name: "Fold",
+		category: "functional"
+	},
+	{
+		name: "Map",
+		category: "functional"
+	},
+	{
+		name: "Reduce",
+		category: "functional"
+	},
+	{
+		name: "StrictMap",
+		category: "functional"
+	},
+	{
+		name: "BernoulliB",
+		category: "number_theory"
+	},
+	{
+		name: "Binomial",
+		category: "number_theory"
+	},
+	{
+		name: "CarmichaelLambda",
+		category: "number_theory"
+	},
+	{
+		name: "CatalanNumber",
+		category: "number_theory"
+	},
+	{
+		name: "ChineseRemainder",
+		category: "number_theory"
+	},
+	{
+		name: "Chop",
+		category: "number_theory"
+	},
+	{
+		name: "ContinuedFraction",
+		category: "number_theory"
+	},
+	{
+		name: "DigitCount",
+		category: "number_theory"
+	},
+	{
+		name: "DigitSum",
+		category: "number_theory"
+	},
+	{
+		name: "Divides",
+		category: "number_theory"
+	},
+	{
+		name: "DivisorSigma",
+		category: "number_theory"
+	},
+	{
+		name: "Divisors",
+		category: "number_theory"
+	},
+	{
+		name: "Erf",
+		category: "number_theory"
+	},
+	{
+		name: "Erfc",
+		category: "number_theory"
+	},
+	{
+		name: "ExtendedGCD",
+		category: "number_theory"
+	},
+	{
+		name: "FactorInteger",
+		category: "number_theory"
+	},
+	{
+		name: "Factorial",
+		category: "number_theory"
+	},
+	{
+		name: "FromContinuedFraction",
+		category: "number_theory"
+	},
+	{
+		name: "FromDigits",
+		category: "number_theory"
+	},
+	{
+		name: "GCD",
+		category: "number_theory"
+	},
+	{
+		name: "IntegerDigits",
+		category: "number_theory"
+	},
+	{
+		name: "IntegerSqrt",
+		category: "number_theory"
+	},
+	{
+		name: "IsAbundant",
+		category: "number_theory"
+	},
+	{
+		name: "IsCenteredSquare",
+		category: "number_theory"
+	},
+	{
+		name: "IsHappy",
+		category: "number_theory"
+	},
+	{
+		name: "IsOctahedral",
+		category: "number_theory"
+	},
+	{
+		name: "IsPentagonal",
+		category: "number_theory"
+	},
+	{
+		name: "IsPerfect",
+		category: "number_theory"
+	},
+	{
+		name: "IsPerfectPower",
+		category: "number_theory"
+	},
+	{
+		name: "IsPrime",
+		category: "number_theory"
+	},
+	{
+		name: "IsSquare",
+		category: "number_theory"
+	},
+	{
+		name: "IsSquareFree",
+		category: "number_theory"
+	},
+	{
+		name: "IsTriangular",
+		category: "number_theory"
+	},
+	{
+		name: "JacobiSymbol",
+		category: "number_theory"
+	},
+	{
+		name: "LCM",
+		category: "number_theory"
+	},
+	{
+		name: "LegendreSymbol",
+		category: "number_theory"
+	},
+	{
+		name: "LucasL",
+		category: "number_theory"
+	},
+	{
+		name: "Mod",
+		category: "number_theory"
+	},
+	{
+		name: "ModularInverse",
+		category: "number_theory"
+	},
+	{
+		name: "MultiplicativeOrder",
+		category: "number_theory"
+	},
+	{
+		name: "NextPrime",
+		category: "number_theory"
+	},
+	{
+		name: "NthPrime",
+		category: "number_theory"
+	},
+	{
+		name: "PowerMod",
+		category: "number_theory"
+	},
+	{
+		name: "PrimeFactors",
+		category: "number_theory"
+	},
+	{
+		name: "PrimeNu",
+		category: "number_theory"
+	},
+	{
+		name: "PrimeOmega",
+		category: "number_theory"
+	},
+	{
+		name: "PrimePi",
+		category: "number_theory"
+	},
+	{
+		name: "PrimitiveRoot",
+		category: "number_theory"
+	},
+	{
+		name: "Radical",
+		category: "number_theory"
+	},
+	{
+		name: "Sigma0",
+		category: "number_theory"
+	},
+	{
+		name: "Sigma1",
+		category: "number_theory"
+	},
+	{
+		name: "SigmaMinus1",
+		category: "number_theory"
+	},
+	{
+		name: "Totient",
+		category: "number_theory"
+	},
+	{
+		name: "AGM",
+		category: "special_function"
+	},
+	{
+		name: "AiryAi",
+		category: "special_function"
+	},
+	{
+		name: "AiryAiPrime",
+		category: "special_function"
+	},
+	{
+		name: "AiryBi",
+		category: "special_function"
+	},
+	{
+		name: "AiryBiPrime",
+		category: "special_function"
+	},
+	{
+		name: "BesselI",
+		category: "special_function"
+	},
+	{
+		name: "BesselJ",
+		category: "special_function"
+	},
+	{
+		name: "BesselK",
+		category: "special_function"
+	},
+	{
+		name: "BesselY",
+		category: "special_function"
+	},
+	{
+		name: "Beta",
+		category: "special_function"
+	},
+	{
+		name: "BetaRegularized",
+		category: "special_function"
+	},
+	{
+		name: "EllipticE",
+		category: "special_function"
+	},
+	{
+		name: "EllipticK",
+		category: "special_function"
+	},
+	{
+		name: "ErfInv",
+		category: "special_function"
+	},
+	{
+		name: "Factorial2",
+		category: "special_function"
+	},
+	{
+		name: "Gamma",
+		category: "special_function"
+	},
+	{
+		name: "GammaLn",
+		category: "special_function"
+	},
+	{
+		name: "GammaRegularized",
+		category: "special_function"
+	},
+	{
+		name: "Hypergeometric1F1",
+		category: "special_function"
+	},
+	{
+		name: "Hypergeometric2F1",
+		category: "special_function"
+	},
+	{
+		name: "LambertW",
+		category: "special_function"
+	},
+	{
+		name: "Zeta",
+		category: "special_function"
+	},
+	{
+		name: "BinomialDistribution",
+		category: "statistics"
+	},
+	{
+		name: "CDF",
+		category: "statistics"
+	},
+	{
+		name: "Correlation",
+		category: "statistics"
+	},
+	{
+		name: "Covariance",
+		category: "statistics"
+	},
+	{
+		name: "ExponentialDistribution",
+		category: "statistics"
+	},
+	{
+		name: "InterquartileRange",
+		category: "statistics"
+	},
+	{
+		name: "Kurtosis",
+		category: "statistics"
+	},
+	{
+		name: "LinearRegression",
+		category: "statistics"
+	},
+	{
+		name: "Mode",
+		category: "statistics"
+	},
+	{
+		name: "NormalDistribution",
+		category: "statistics"
+	},
+	{
+		name: "PDF",
+		category: "statistics"
+	},
+	{
+		name: "PoissonDistribution",
+		category: "statistics"
+	},
+	{
+		name: "PolynomialFit",
+		category: "statistics"
+	},
+	{
+		name: "PopulationStandardDeviation",
+		category: "statistics"
+	},
+	{
+		name: "PopulationVariance",
+		category: "statistics"
+	},
+	{
+		name: "Quantile",
+		category: "statistics"
+	},
+	{
+		name: "Quartiles",
+		category: "statistics"
+	},
+	{
+		name: "Skewness",
+		category: "statistics"
+	},
+	{
+		name: "StandardDeviation",
+		category: "statistics"
+	},
+	{
+		name: "UniformDistribution",
+		category: "statistics"
+	},
+	{
+		name: "Variance",
+		category: "statistics"
+	},
+	{
+		name: "Arctan2",
+		category: "string"
+	},
+	{
+		name: "CaseFold",
+		category: "string"
+	},
+	{
+		name: "Characters",
+		category: "string"
+	},
+	{
+		name: "DigitsFrom",
+		category: "string"
+	},
+	{
+		name: "GraphemeClusters",
+		category: "string"
+	},
+	{
+		name: "IntegerString",
+		category: "string"
+	},
+	{
+		name: "IsMatch",
+		category: "string"
+	},
+	{
+		name: "NumberFrom",
+		category: "string"
+	},
+	{
+		name: "PadEnd",
+		category: "string"
+	},
+	{
+		name: "PadStart",
+		category: "string"
+	},
+	{
+		name: "RegExp",
+		category: "string"
+	},
+	{
+		name: "Str",
+		category: "string"
+	},
+	{
+		name: "String",
+		category: "string"
+	},
+	{
+		name: "StringCompare",
+		category: "string"
+	},
+	{
+		name: "StringFrom",
+		category: "string"
+	},
+	{
+		name: "StringJoin",
+		category: "string"
+	},
+	{
+		name: "StringMatch",
+		category: "string"
+	},
+	{
+		name: "StringMatchAll",
+		category: "string"
+	},
+	{
+		name: "StringRepeat",
+		category: "string"
+	},
+	{
+		name: "StringReplace",
+		category: "string"
+	},
+	{
+		name: "StringSplit",
+		category: "string"
+	},
+	{
+		name: "ToLowerCase",
+		category: "string"
+	},
+	{
+		name: "ToUpperCase",
+		category: "string"
+	},
+	{
+		name: "Trim",
+		category: "string"
+	},
+	{
+		name: "TrimEnd",
+		category: "string"
+	},
+	{
+		name: "TrimStart",
+		category: "string"
+	},
+	{
+		name: "UnicodeScalars",
+		category: "string"
+	},
+	{
+		name: "Utf16",
+		category: "string"
+	},
+	{
+		name: "Utf8",
+		category: "string"
+	},
+	{
+		name: "Arccos",
+		category: "trigonometric"
+	},
+	{
+		name: "Arccot",
+		category: "trigonometric"
+	},
+	{
+		name: "Arccsc",
+		category: "trigonometric"
+	},
+	{
+		name: "Arcosh",
+		category: "trigonometric"
+	},
+	{
+		name: "Arcoth",
+		category: "trigonometric"
+	},
+	{
+		name: "Arcsch",
+		category: "trigonometric"
+	},
+	{
+		name: "Arcsec",
+		category: "trigonometric"
+	},
+	{
+		name: "Arcsin",
+		category: "trigonometric"
+	},
+	{
+		name: "Arctan",
+		category: "trigonometric"
+	},
+	{
+		name: "Arsech",
+		category: "trigonometric"
+	},
+	{
+		name: "Arsinh",
+		category: "trigonometric"
+	},
+	{
+		name: "Artanh",
+		category: "trigonometric"
+	},
+	{
+		name: "Cos",
+		category: "trigonometric"
+	},
+	{
+		name: "Cosh",
+		category: "trigonometric"
+	},
+	{
+		name: "Cot",
+		category: "trigonometric"
+	},
+	{
+		name: "Coth",
+		category: "trigonometric"
+	},
+	{
+		name: "Csc",
+		category: "trigonometric"
+	},
+	{
+		name: "Csch",
+		category: "trigonometric"
+	},
+	{
+		name: "Hypot",
+		category: "trigonometric"
+	},
+	{
+		name: "Pi",
+		category: "trigonometric"
+	},
+	{
+		name: "Sec",
+		category: "trigonometric"
+	},
+	{
+		name: "Sech",
+		category: "trigonometric"
+	},
+	{
+		name: "Sin",
+		category: "trigonometric"
+	},
+	{
+		name: "Sinc",
+		category: "trigonometric"
+	},
+	{
+		name: "Sinh",
+		category: "trigonometric"
+	},
+	{
+		name: "Tan",
+		category: "trigonometric"
+	},
+	{
+		name: "Tanh",
+		category: "trigonometric"
+	}
+], Ie = {
+	Add: [{
+		label: "value",
+		variadic: !0
+	}],
+	Subtract: [{
+		label: "value",
+		variadic: !0
+	}],
+	Multiply: [{
+		label: "value",
+		variadic: !0
+	}],
+	Divide: [{ label: "numerator" }, { label: "denominator" }],
+	Negate: [{ label: "value" }],
+	Power: [{ label: "base" }, { label: "exponent" }],
+	Sqrt: [{ label: "value" }],
+	Square: [{ label: "value" }],
+	Root: [{ label: "value" }, { label: "degree" }],
+	Round: [{ label: "value" }, {
+		label: "digits",
+		optional: !0,
+		defaultValue: 0
+	}],
+	Floor: [{ label: "value" }],
+	Ceil: [{ label: "value" }],
+	Abs: [{ label: "value" }],
+	Min: [{
+		label: "value",
+		variadic: !0
+	}],
+	Max: [{
+		label: "value",
+		variadic: !0
+	}],
+	Average: [{
+		label: "value",
+		variadic: !0
+	}],
+	Median: [{
+		label: "value",
+		variadic: !0
+	}],
+	Sum: [{
+		label: "value",
+		variadic: !0
+	}],
+	Product: [{ label: "values" }],
+	Clamp: [
+		{ label: "value" },
+		{ label: "min" },
+		{ label: "max" }
+	],
+	Mod: [{ label: "value" }, { label: "divisor" }],
+	If: [
+		{
+			label: "condition",
+			defaultValue: !0
+		},
+		{ label: "then" },
+		{ label: "else" }
+	],
+	Switch: [{
+		label: "value / case / result ...",
+		variadic: !0
+	}],
+	Which: [{
+		label: "condition / result ...",
+		variadic: !0
+	}],
+	Equal: [{ label: "a" }, { label: "b" }],
+	NotEqual: [{ label: "a" }, { label: "b" }],
+	Greater: [{ label: "a" }, { label: "b" }],
+	GreaterEqual: [{ label: "a" }, { label: "b" }],
+	Less: [{ label: "a" }, { label: "b" }],
+	LessEqual: [{ label: "a" }, { label: "b" }],
+	And: [{
+		label: "condition",
+		variadic: !0
+	}],
+	Or: [{
+		label: "condition",
+		variadic: !0
+	}],
+	Not: [{ label: "condition" }],
+	StringJoin: [{
+		label: "value",
+		variadic: !0
+	}],
+	ToUpperCase: [{ label: "text" }],
+	ToLowerCase: [{ label: "text" }],
+	Trim: [{ label: "text" }]
+}, Le = {
+	Add: "Addition",
+	Subtract: "Subtraction",
+	Multiply: "Multiplication",
+	And: "And",
+	Or: "Or",
+	Divide: "Division",
+	Power: "Power",
+	Square: "Square",
+	Sqrt: "Square Root",
+	Root: "Root",
+	Sum: "Sum",
+	Product: "Product",
+	Equal: "Equal To",
+	NotEqual: "Not Equal To",
+	Greater: "Greater Than",
+	GreaterEqual: "Greater Than or Equal To",
+	Less: "Less Than",
+	LessEqual: "Less Than or Equal To",
+	In: "In",
+	NotIn: "Not In",
+	Contains: "Contains",
+	ContainsAnyOf: "Contains Any Of",
+	ContainsAllOf: "Contains All Of",
+	ContainsNoneOf: "Contains None Of",
+	Subset: "Subset Of",
+	SubsetEqual: "Subset Of Or Equal To",
+	Superset: "Superset Of",
+	SupersetEqual: "Superset Of Or Equal To",
+	NotSubset: "Not A Subset Of",
+	NotSuperset: "Not A Superset Of",
+	Element: "In Range",
+	NotElement: "Not In Range",
+	Array: "List",
+	List: "List"
+}, Re = {
+	Add: {
+		kind: "infix",
+		symbol: "+"
+	},
+	Subtract: {
+		kind: "infix",
+		symbol: "−"
+	},
+	Multiply: {
+		kind: "infix",
+		symbol: "·"
+	},
+	And: {
+		kind: "infix",
+		symbol: "∧"
+	},
+	Or: {
+		kind: "infix",
+		symbol: "∨"
+	},
+	Divide: { kind: "fraction" },
+	Power: { kind: "power" },
+	Square: {
+		kind: "power",
+		symbol: "2"
+	},
+	Sqrt: { kind: "sqrt" },
+	Root: { kind: "root" },
+	Sum: {
+		kind: "reducer",
+		symbol: "Σ"
+	},
+	Product: {
+		kind: "reducer",
+		symbol: "Π"
+	},
+	Array: { kind: "array" },
+	List: { kind: "array" },
+	Equal: {
+		kind: "comparison",
+		symbol: "="
+	},
+	NotEqual: {
+		kind: "comparison",
+		symbol: "≠"
+	},
+	Greater: {
+		kind: "comparison",
+		symbol: ">"
+	},
+	GreaterEqual: {
+		kind: "comparison",
+		symbol: "≥"
+	},
+	Less: {
+		kind: "comparison",
+		symbol: "<"
+	},
+	LessEqual: {
+		kind: "comparison",
+		symbol: "≤"
+	},
+	In: {
+		kind: "comparison",
+		symbol: "in"
+	},
+	NotIn: {
+		kind: "comparison",
+		symbol: "not in"
+	},
+	Contains: {
+		kind: "comparison",
+		symbol: "contains"
+	},
+	ContainsAnyOf: {
+		kind: "comparison",
+		symbol: "contains any of"
+	},
+	ContainsAllOf: {
+		kind: "comparison",
+		symbol: "contains all of"
+	},
+	ContainsNoneOf: {
+		kind: "comparison",
+		symbol: "contains none of"
+	},
+	Subset: {
+		kind: "comparison",
+		symbol: "⊂"
+	},
+	SubsetEqual: {
+		kind: "comparison",
+		symbol: "⊆"
+	},
+	Superset: {
+		kind: "comparison",
+		symbol: "⊃"
+	},
+	SupersetEqual: {
+		kind: "comparison",
+		symbol: "⊇"
+	},
+	NotSubset: {
+		kind: "comparison",
+		symbol: "⊄"
+	},
+	NotSuperset: {
+		kind: "comparison",
+		symbol: "⊅"
+	}
+}, ze = [
+	"Equal",
+	"NotEqual",
+	"Greater",
+	"GreaterEqual",
+	"Less",
+	"LessEqual",
+	"In",
+	"NotIn",
+	"Contains",
+	"ContainsAnyOf",
+	"ContainsAllOf",
+	"ContainsNoneOf",
+	"Subset",
+	"SubsetEqual",
+	"Superset",
+	"SupersetEqual",
+	"NotSubset",
+	"NotSuperset"
+], Be = [
+	[
+		"Add",
+		"Subtract",
+		"Multiply"
+	],
+	["And", "Or"],
+	ze
+];
+function Ve(e) {
+	let t = Be.find((t) => t.includes(e));
+	return t ? t.filter((t) => t !== e) : [];
+}
+function He(e) {
+	return ze.includes(e);
+}
+var Ue = /* @__PURE__ */ new Set(["Contains"]);
+function We(e, t) {
+	return Ue.has(e) !== Ue.has(t);
+}
+function Ge(e) {
+	return Re[e]?.symbol ?? e;
+}
+//#endregion
+//#region src/registry/registry.ts
+var Ke = new Map(K.map((e) => [e.name, {
+	...e,
+	args: Ie[e.name]
+}]));
+function qe() {
+	return K;
+}
+function q(e) {
+	return Ke.get(e);
+}
+function Je(e) {
+	return Re[e];
+}
+function Ye(e) {
+	return Fe[e] ?? e;
+}
+function J(e) {
+	return Le[e] ?? e;
+}
+function Xe(e) {
+	let t = q(e)?.args;
+	if (!t || t.length === 0) return;
+	if (t[t.length - 1]?.variadic) return {
+		min: t.length,
+		max: Infinity
+	};
+	let n = t.filter((e) => e.optional).length;
+	return {
+		min: t.length - n,
+		max: t.length
+	};
+}
+function Ze(e, t = []) {
+	let n = e.trim().toLowerCase(), r = new Set(t);
+	return K.filter((e) => r.has(e.name) ? !1 : !n || e.name.toLowerCase().includes(n) || Ye(e.category).toLowerCase().includes(n));
+}
+function Y(e) {
+	let t = Je(e);
+	if (t) switch (t.kind) {
+		case "fraction": return [0, 1];
+		case "power": return e === "Square" ? [0] : [0, 2];
+		case "sqrt": return [0];
+		case "root": return [0, 2];
+		case "comparison": return [0, 0];
+		case "infix": return e === "And" || e === "Or" ? [!0, !0] : [0, 0];
+		case "reducer": return e === "Product" ? [["Array", 1]] : [0];
+	}
+	let n = q(e);
+	return n?.args?.length ? n.args.map((e) => e.defaultValue ?? 0) : [0];
+}
+//#endregion
+//#region src/registry/notation-shape.ts
+function Qe(e, t, n) {
+	switch (t.kind) {
+		case "infix": return n.length >= 3;
+		case "fraction":
+		case "comparison": return n.length === 3;
+		case "power": return e === "Square" ? n.length === 2 : n.length === 3;
+		case "sqrt": return n.length === 2;
+		case "root": return n.length === 3;
+		case "reducer":
+			if (e === "Product") {
+				let e = n[1];
+				return n.length === 2 && e !== void 0 && B(e) && e[0] === "Array";
+			}
+			return n.length >= 2;
+		case "array": return !0;
+	}
+}
+//#endregion
+//#region src/styles.ts
+var $e = o`
+  :host {
+    --mjtb-font-family: ui-sans-serif, system-ui, -apple-system, sans-serif;
+    --mjtb-font-size: 14px;
+    --mjtb-text: light-dark(#1f2023, #e7e7ea);
+    --mjtb-bg: light-dark(#ffffff, #1c1c1f);
+    --mjtb-node-bg: light-dark(#f7f7f9, #29292e);
+    --mjtb-node-border: light-dark(#dcdce1, #3c3c42);
+    --mjtb-accent: light-dark(#4f46e5, #8583f0);
+    --mjtb-danger: light-dark(#dc2626, #f87171);
+    --mjtb-radius: 6px;
+
+    color-scheme: light dark;
+    display: inline-block;
+    font-family: var(--mjtb-font-family);
+    font-size: var(--mjtb-font-size);
+    color: var(--mjtb-text);
+    background: var(--mjtb-bg);
+  }
+
+  * {
+    box-sizing: border-box;
+  }
+
+  .mjtb-root {
+    display: inline-block;
+  }
+
+  .mjtb-toolbar {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 8px;
+  }
+
+  .mode-toggle {
+    font: inherit;
+    padding: 3px 9px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+    color: inherit;
+    cursor: pointer;
+  }
+
+  .mode-toggle:hover {
+    border-color: var(--mjtb-accent);
+  }
+
+  .mode-toggle:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+  }
+
+  .json-error-hint {
+    font-size: 0.85em;
+    color: var(--mjtb-danger);
+  }
+
+  .json-view {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+  }
+
+  .json-textarea {
+    display: block;
+    width: 100%;
+    min-width: 320px;
+    min-height: 200px;
+    box-sizing: border-box;
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 0.95em;
+    line-height: 1.4;
+    tab-size: 2;
+    padding: 10px;
+    border: 1px solid var(--mjtb-node-border);
+    border-radius: var(--mjtb-radius);
+    background: var(--mjtb-node-bg);
+    color: inherit;
+    resize: vertical;
+  }
+
+  .json-textarea:focus-visible {
+    outline: 2px solid var(--mjtb-accent);
+    outline-offset: 1px;
+  }
+
+  .json-error {
+    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+    font-size: 0.85em;
+    color: var(--mjtb-danger);
+    background: color-mix(in srgb, var(--mjtb-danger) 10%, transparent);
+    border: 1px solid var(--mjtb-danger);
+    border-radius: 4px;
+    padding: 6px 8px;
+    white-space: pre-wrap;
+  }
+
+  /*
+   * Shared base: every construct box is an inline-flex row with its menu
+   * trailing alongside it. Only .generic (the boxed fallback) opts into
+   * the bordered-card chrome and column stacking — the curated notation
+   * kinds stay visually plain so they read as math, not as nested
+   * cards. Every node is click-to-edit: plain content until it's the
+   * active one, so a hover tint is a notation box's only "this is
+   * clickable" hint (.generic already reads as a box on its own).
+   */
+  .node.construct {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    vertical-align: middle;
+    border-radius: 4px;
+    cursor: pointer;
+    /* Positioning context for .construct-menu's .popover below — anchors
+       the open menu to the whole node's own box, not to the small
+       trailing trigger it no longer visibly has. */
+    position: relative;
+  }
+
+  .node.construct.generic {
+    flex-direction: column;
+    align-items: stretch;
+    gap: 4px;
+    padding: 6px 8px;
+    background: var(--mjtb-node-bg);
+    border: 1px solid var(--mjtb-node-border);
+    border-radius: var(--mjtb-radius);
+  }
+
+  /*
+   * :hover is true for every ancestor box the pointer happens to be
+   * over, not just the innermost one under the cursor — nested notation
+   * boxes overlap almost entirely (e.g. a comparison as the last operand
+   * of an And chain), so without :has() here, hovering the innermost one
+   * would light up every construct wrapping it too, all the way up,
+   * reading as "the whole expression" rather than the specific node a
+   * click would activate. :has(...:hover) lets an ancestor notice it
+   * contains a more specific hover target and step aside so only the
+   * true innermost one highlights.
+   */
+  .node.construct:not(.generic):hover:not(:has(.node.construct:hover, .value-text:hover)) {
+    background: var(--mjtb-node-bg);
+  }
+
+  .construct-header {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    flex-wrap: wrap;
+  }
+
+  .construct-name {
+    font-weight: 600;
+  }
+
+  .construct-category {
+    font-size: 0.75em;
+    opacity: 0.6;
+  }
+
+  .construct-args {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    padding-left: 14px;
+    border-left: 2px solid var(--mjtb-node-border);
+  }
+
+  /* Constants: named, individually collapsible bindings, then a
+     final expression — visually distinct from a plain argument list so
+     a name reads as a name, not an anonymous positional argument. */
+  .constants-bindings {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+    margin: 2px 0;
+  }
+
+  .constant-card {
+    border: 1px solid var(--mjtb-node-border);
+    border-radius: 4px;
+    padding: 4px 6px;
+    background: var(--mjtb-bg);
+  }
+
+  .constant-header {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .fold-toggle {
+    font: inherit;
+    line-height: 1;
+    padding: 2px 6px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+    color: inherit;
+    cursor: pointer;
+  }
+
+  .fold-toggle:hover {
+    border-color: var(--mjtb-accent);
+  }
+
+  .constant-name .value-text,
+  .constant-name input {
+    font-weight: 600;
+  }
+
+  .small-remove {
+    font: inherit;
+    line-height: 1;
+    margin-left: auto;
+    padding: 2px 6px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+    color: var(--mjtb-danger);
+    cursor: pointer;
+  }
+
+  .small-remove:hover {
+    border-color: var(--mjtb-danger);
+  }
+
+  .constant-value {
+    display: block;
+    margin-top: 4px;
+    padding-left: 14px;
+    border-left: 2px solid var(--mjtb-node-border);
+  }
+
+  .constants-final {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    margin-top: 6px;
+    padding-top: 6px;
+    border-top: 1px dashed var(--mjtb-node-border);
+  }
+
+  /* If (both the flat CortexJS form and the pair/elseif-chain form share
+     this same row layout — see #renderIf). */
+  .if-branches {
+    display: flex;
+    flex-direction: column;
+    gap: 4px;
+  }
+
+  .if-row {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    flex-wrap: wrap;
+  }
+
+  .if-keyword {
+    font-size: 0.75em;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.02em;
+    opacity: 0.6;
+  }
+
+  .slot {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    flex-wrap: wrap;
+  }
+
+  .arg-label {
+    font-size: 0.75em;
+    opacity: 0.6;
+  }
+
+  input[type="number"],
+  input[type="text"],
+  input[type="search"] {
+    font: inherit;
+    padding: 2px 4px;
+    border: 1px solid var(--mjtb-node-border);
+    border-radius: 4px;
+    background: var(--mjtb-bg);
+    color: inherit;
+    width: 6em;
+  }
+
+  input[type="search"] {
+    width: 12em;
+  }
+
+  .symbol-select {
+    font: inherit;
+    padding: 2px 4px;
+    border: 1px solid var(--mjtb-accent);
+    border-radius: 4px;
+    background: var(--mjtb-bg);
+    color: inherit;
+    max-width: 16em;
+  }
+
+  .symbol-chip {
+    background: color-mix(in srgb, var(--mjtb-accent) 15%, transparent);
+    border: 1px solid var(--mjtb-accent);
+    border-radius: 999px;
+    padding: 1px 10px;
+    white-space: nowrap;
+    cursor: pointer;
+  }
+
+  /* Read-mode literal: plain text, not an input, until activated. */
+  .value-text {
+    display: inline-block;
+    min-width: 0.75em;
+    min-height: 1.2em;
+    padding: 1px 4px;
+    margin: -1px -4px;
+    border-radius: 4px;
+    cursor: pointer;
+  }
+
+  .value-text:hover {
+    background: var(--mjtb-node-bg);
+  }
+
+  [tabindex="0"]:focus-visible {
+    outline: 2px solid var(--mjtb-accent);
+    outline-offset: 2px;
+    border-radius: 4px;
+  }
+
+  .bool-toggle {
+    font: inherit;
+    line-height: 1;
+    padding: 3px 7px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+    color: inherit;
+    cursor: pointer;
+  }
+
+  .bool-toggle:hover {
+    border-color: var(--mjtb-accent);
+  }
+
+  /*
+   * Every slot/node exposes exactly one visible affordance — a "⋯" trigger
+   * — rather than a row of individual icon buttons, to keep a deeply
+   * nested tree from turning into a wall of buttons. Everything that used
+   * to be its own button (change type, insert symbol, wrap, remove, ...)
+   * is a labeled item in this one popover instead.
+   */
+  .picker {
+    position: relative;
+    display: inline-block;
+    /* A context menu is UI chrome, not notation content — it must never
+       shrink just because it's nested inside a scaled-down exponent/
+       degree/reducer-symbol (or several, compounded). Resetting the size
+       here, not just at those individual rules, keeps it correct no
+       matter what scaling exists elsewhere now or is added later. */
+    font-size: var(--mjtb-font-size);
+  }
+
+  .picker > summary {
+    list-style: none;
+    cursor: pointer;
+    font: inherit;
+    padding: 3px 7px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+  }
+
+  .picker > summary::-webkit-details-marker {
+    display: none;
+  }
+
+  .picker .popover {
+    position: absolute;
+    top: calc(100% + 4px);
+    left: 0;
+    z-index: 10;
+    display: block;
+    background: var(--mjtb-bg);
+    border: 1px solid var(--mjtb-node-border);
+    border-radius: 4px;
+    padding: 4px;
+    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+  }
+
+  /*
+   * The construct-level menu opens the instant its node activates (see
+   * #customMenu), so — unlike the leaf menu — it has no click-to-open
+   * trigger left to show. Hiding the summary and giving up this
+   * element's own position: relative (falling back to .node.construct's,
+   * set above) means .popover anchors to the whole node's own box: it
+   * collapses to zero size (an empty inline-block with an
+   * absolutely-positioned-only child needs no help from display:contents
+   * to do that) and the menu appears directly under whatever you
+   * actually clicked, not trailing off after it.
+   */
+  .picker.construct-menu {
+    position: static;
+  }
+
+  .picker.construct-menu > summary {
+    display: none;
+  }
+
+  /* Centered under the whole node rather than left-aligned to it — for a
+     long infix/comparison chain, the click that opened this could have
+     landed anywhere along the line, so centering under the full node
+     reads as closer to "under what you clicked" than always jumping to
+     the line's start would. */
+  .picker.construct-menu .popover {
+    left: 50%;
+    transform: translateX(-50%);
+  }
+
+  .menu-popover {
+    display: flex;
+    flex-direction: column;
+    gap: 1px;
+    min-width: 160px;
+  }
+
+  .menu-item {
+    display: block;
+    width: 100%;
+    text-align: left;
+    font: inherit;
+    padding: 6px 8px;
+    border: none;
+    border-radius: 4px;
+    background: none;
+    color: inherit;
+    cursor: pointer;
+  }
+
+  .menu-item:hover {
+    background: var(--mjtb-node-bg);
+  }
+
+  .menu-item.danger {
+    color: var(--mjtb-danger);
+  }
+
+  /* Non-clickable: identifies which node this menu belongs to. */
+  .menu-header {
+    padding: 4px 8px 6px;
+    margin-bottom: 2px;
+    border-bottom: 1px solid var(--mjtb-node-border);
+    font-size: 0.75em;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.02em;
+    opacity: 0.6;
+    cursor: default;
+    user-select: none;
+    white-space: nowrap;
+  }
+
+  /* A submenu is a menu item that expands into its own search popover. */
+  .submenu {
+    position: relative;
+  }
+
+  .submenu > summary {
+    list-style: none;
+    cursor: pointer;
+    font: inherit;
+    display: block;
+    padding: 6px 8px;
+    border-radius: 4px;
+  }
+
+  .submenu > summary::-webkit-details-marker {
+    display: none;
+  }
+
+  .submenu > summary:hover {
+    background: var(--mjtb-node-bg);
+  }
+
+  .submenu .popover {
+    top: 0;
+    left: calc(100% + 4px);
+  }
+
+  /* "Change operator…" (swapTargets): a small known set, so a flat grid of
+     symbol/short-text buttons beats a searchable picker. For the
+     comparison/membership/subset group, "In range…"/"Not in range…"
+     (structural conversions, not plain renames) stack below the grid as
+     regular full-width menu items instead. */
+  .operator-menu {
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+  }
+
+  .operator-grid {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 4px;
+    width: 11em;
+  }
+
+  .operator-btn {
+    flex: 1 0 calc(33% - 4px);
+    font: inherit;
+    font-size: 1.1em;
+    line-height: 1;
+    padding: 4px 8px;
+    border-radius: 4px;
+    border: 1px solid var(--mjtb-node-border);
+    background: var(--mjtb-bg);
+    color: inherit;
+    cursor: pointer;
+    white-space: nowrap;
+  }
+
+  .operator-btn:hover {
+    border-color: var(--mjtb-accent);
+  }
+
+  /* --- notation --- */
+
+  .infix-row {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    flex-wrap: wrap;
+  }
+
+  .infix-stacked {
+    display: inline-flex;
+    flex-direction: column;
+    align-items: flex-start;
+    gap: 4px;
+  }
+
+  .infix-stacked-row {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+  }
+
+  .op {
+    opacity: 0.75;
+    padding: 0 2px;
+  }
+
+  .reducer-symbol {
+    /* Anchored to the fixed component base, not em off the current
+       (possibly already-scaled) context - a reducer nested inside another
+       reducer (or an exponent, or several) must not keep compounding
+       bigger/smaller each level. Same reasoning throughout this file
+       wherever notation scales a nested subtree: .power-exp,
+       .radical-degree. */
+    font-size: calc(var(--mjtb-font-size) * 1.3);
+    font-weight: 600;
+    margin-right: 2px;
+  }
+
+  .comma {
+    opacity: 0.6;
+  }
+
+  .frac {
+    display: inline-grid;
+    grid-template-rows: auto auto auto;
+    justify-items: center;
+    vertical-align: middle;
+    padding: 2px 4px;
+  }
+  .frac-line {
+    width: 100%;
+    border-bottom: 1.5px solid currentColor;
+    margin: 2px 0;
+  }
+
+  /*
+   * Real flex top-alignment, not a transform: .power-base and .power-exp
+   * start from the same top edge, and the exponent's smaller font-size
+   * alone makes it read as raised - no extra shift needed. This matters
+   * for two things a transform gets wrong: (1) a transform repositions
+   * pixels without resizing the box, so an ancestor (e.g. a fraction's
+   * denominator row) wouldn't grow to fit a raised exponent and it could
+   * visually cross above the dividing line; (2) flex-start aligns to the
+   * TOP of whichever sibling is tallest, so a compound, parenthesized,
+   * multi-line base (e.g. (1/2)^2) still gets its exponent placed at the
+   * base's top-right, not vertically centered against it. Do not add
+   * vertical-align here instead: .power-base is itself a flex container
+   * (for the stretchy parens below) whose first child is an empty
+   * decorative span, and flexbox synthesizes a container's baseline from
+   * its first item's margin edge when that item has no real one - here
+   * that's the *bottom* of the stretched paren, so vertical-align would
+   * raise the exponent relative to the wrong (bottom-anchored) baseline
+   * and it would barely lift off the bottom at all.
+   */
+  .power-frame {
+    display: inline-flex;
+    align-items: flex-start;
+  }
+
+  .power-exp {
+    /* calc() off the fixed base, not em off the parent - see the
+       .reducer-symbol comment above. Without this, nesting Power inside
+       its own exponent a few times shrinks the text (and the menu
+       inside it, before the .picker fix above) to unreadable. */
+    font-size: calc(var(--mjtb-font-size) * 0.7);
+  }
+
+  /*
+   * Marks the boundary of a compound base, e.g. (x+y)^2 - without this,
+   * a base that's itself a multi-term expression reads ambiguously once
+   * a bare exponent is stacked on top of it. .paren (an inline SVG, see
+   * the PAREN_OPEN/PAREN_CLOSE doc comment in element.ts) is stretched to
+   * the full height of .power-base by that flex container's default
+   * align-items:stretch - a plain text glyph sits at one fixed
+   * line-height and would only ever wrap the *first line* of a tall
+   * base (e.g. a fraction), never visually embracing all of it.
+   */
+  .power-base {
+    display: inline-flex;
+    align-items: stretch;
+  }
+
+  .paren {
+    width: 0.3em;
+    overflow: visible;
+    opacity: 0.7;
+  }
+
+  .paren path {
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 1.6;
+    stroke-linecap: round;
+    vector-effect: non-scaling-stroke;
+  }
+
+  /*
+   * A dedicated span, not the outer "node construct radical" element
+   * itself: .node.construct's own align-items: center (two classes)
+   * would otherwise beat this rule's align-items: stretch (one class)
+   * in the cascade no matter the source order, same as .power-base.
+   *
+   * align-items: stretch (not flex-end, as this used to be): the hook's
+   * SVG needs to be told to actually fill the row's full height — same
+   * reasoning as .power-base above. Without it, a tall radicand (e.g.
+   * one containing a fraction) grows past a hook that stayed pinned to
+   * one fixed line-height, exactly the "broken roots" this replaced.
+   */
+  .radical-frame {
+    display: inline-flex;
+    align-items: stretch;
+  }
+
+  .radical-degree {
+    /* Stays pinned near the top notch regardless of how tall the row
+       stretches — real typesetting keeps the degree small and near the
+       top no matter how large the radicand is, it never scales with it. */
+    align-self: flex-start;
+    font-size: calc(var(--mjtb-font-size) * 0.65);
+    margin-right: -0.15em;
+    position: relative;
+    top: -0.15em;
+  }
+
+  .radical-hook {
+    width: 0.5em;
+    overflow: visible;
+    flex-shrink: 0;
+  }
+
+  .radical-hook path {
+    fill: none;
+    stroke: currentColor;
+    stroke-width: 1.6;
+    stroke-linecap: round;
+    stroke-linejoin: round;
+    vector-effect: non-scaling-stroke;
+  }
+
+  .radical-sign {
+    /* Flush against the hook's top-right point (see ROOT_HOOK's own
+       comment) so the vinculum reads as one continuous line, not two
+       disconnected pieces. A little padding-top, though, so the radicand
+       itself doesn't touch the vinculum — same reason a fraction bar
+       doesn't sit flush against its numerator. */
+    border-top: 1.5px solid currentColor;
+    padding: 2px 3px 0 2px;
+  }
+
+  .comparison {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+  }
+`;
+//#endregion
+//#region \0@oxc-project+runtime@0.149.0/helpers/esm/decorate.js
+function X(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region src/element.ts
+var Z = (e) => e.length ? e.join(".") : "root", et = {
+	number: "Number",
+	boolean: "Boolean",
+	text: "Text",
+	symbol: "Symbol"
+}, tt = O`<svg class="paren" viewBox="0 0 10 100" preserveAspectRatio="none" aria-hidden="true">
+  <path d="M 7,3 Q 1,50 7,97" />
+</svg>`, nt = O`<svg class="paren" viewBox="0 0 10 100" preserveAspectRatio="none" aria-hidden="true">
+  <path d="M 3,3 Q 9,50 3,97" />
+</svg>`, rt = O`<svg class="radical-hook" viewBox="0 0 20 100" preserveAspectRatio="none" aria-hidden="true">
+  <path d="M 0,55 L 6,97 L 19,3" />
+</svg>`;
+function it(e) {
+	let t = new Set(e.map((e) => Array.isArray(e) && typeof e[0] == "string" ? e[0] : null).filter((e) => e !== null));
+	if (!t.has("constant")) return "constant";
+	let n = 2;
+	for (; t.has(`constant_${n}`);) n++;
+	return `constant_${n}`;
+}
+function at(e) {
+	return !Array.isArray(e) || e.length > 0 && typeof e[0] == "string" && q(e[0]) !== void 0;
+}
+function Q(e) {
+	let t = e;
+	for (; t;) t instanceof HTMLDetailsElement && (t.open = !1), t = t.parentElement;
+}
+var $ = class extends L {
+	constructor(...e) {
+		super(...e), this.value = 0, this.symbols = [], this.blacklist = [], this.inlineToStackedThreshold = 3, this.activePath = null, this.jsonMode = !1, this.jsonDraft = "", this.jsonError = null, this.expandedConstants = /* @__PURE__ */ new Set(), this.#i = (e) => {
+			let t = e.target.closest("[data-path]");
+			t && (this.activePath = t.dataset.path ?? null);
+		}, this.#a = (e) => {
+			e.key === "Escape" && this.activePath && (this.activePath = null, (this.shadowRoot?.activeElement)?.blur());
+		}, this.#o = (e) => {
+			this.activePath && !e.composedPath().includes(this) && (this.activePath = null);
+		};
+	}
+	static {
+		this.styles = $e;
+	}
+	#e(e) {
+		let t = new Set(this.expandedConstants);
+		t.has(e) ? t.delete(e) : t.add(e), this.expandedConstants = t;
+	}
+	#t(e, t) {
+		this.value = U(this.value, e, t), this.#n();
+	}
+	#n() {
+		this.dispatchEvent(new CustomEvent("change", {
+			detail: { value: this.value },
+			bubbles: !0,
+			composed: !0
+		}));
+	}
+	#r(e) {
+		this.activePath = null;
+		let t = e.slice(0, -1), n = e[e.length - 1], r = H(this.value, t);
+		this.#t(t, Ae(r, n));
+	}
+	#i;
+	#a;
+	#o;
+	connectedCallback() {
+		super.connectedCallback(), document.addEventListener("click", this.#o);
+	}
+	disconnectedCallback() {
+		document.removeEventListener("click", this.#o), super.disconnectedCallback();
+	}
+	updated(e) {
+		if (!e.has("activePath") || !this.activePath) return;
+		let t = this.shadowRoot?.querySelector(".slot-leaf.active > input[type=\"number\"], .slot-leaf.active > input[type=\"text\"], .slot-leaf.active > select");
+		t && this.shadowRoot?.activeElement !== t && (t.focus(), t instanceof HTMLInputElement && t.select());
+	}
+	#s() {
+		if (this.jsonMode) {
+			if (this.jsonError) return;
+			this.jsonMode = !1;
+			return;
+		}
+		this.activePath = null, this.jsonDraft = JSON.stringify(this.value, null, 2), this.jsonError = null, this.jsonMode = !0;
+	}
+	#c(e) {
+		this.jsonDraft = e;
+		let t;
+		try {
+			t = JSON.parse(e);
+		} catch (e) {
+			this.jsonError = e instanceof Error ? e.message : "Invalid JSON";
+			return;
+		}
+		if (!V(t)) {
+			this.jsonError = "Not a valid MathJSON expression — expected a number, boolean, string, or array.";
+			return;
+		}
+		this.jsonError = null, this.value = t, this.#n();
+	}
+	#l() {
+		return O`<div class="json-view">
+      <textarea
+        class="json-textarea"
+        spellcheck="false"
+        .value=${this.jsonDraft}
+        @input=${(e) => this.#c(e.currentTarget.value)}
+      ></textarea>
+      ${this.jsonError ? O`<div class="json-error">${this.jsonError}</div>` : A}
+    </div>`;
+	}
+	render() {
+		return O`<div class="mjtb-toolbar">
+        <button class="mode-toggle" ?disabled=${this.jsonMode && !!this.jsonError} @click=${() => this.#s()}>
+          ${this.jsonMode ? "Tree view" : "JSON view"}
+        </button>
+        ${this.jsonMode && this.jsonError ? O`<span class="json-error-hint">Fix the error below to switch back</span>` : A}
+      </div>
+      ${this.jsonMode ? this.#l() : O`<div class="mjtb-root" @focusin=${this.#i} @keydown=${this.#a}>
+            ${this.#u(this.value, [], void 0, !1)}
+          </div>`}`;
+	}
+	#u(e, t, n, r) {
+		let i = Pe(e, this.symbols), a = Z(t), o = this.activePath === a;
+		if (i === "function") return O`<span class="slot slot-function">
+        ${n ? O`<span class="arg-label">${n}</span>` : A}
+        ${this.#p(e, t, r)}
+      </span>`;
+		if (i === "symbol") {
+			let s = G(this.symbols, e);
+			return o ? O`<span class="slot slot-leaf active" data-kind="symbol" data-path=${a}>
+        ${n ? O`<span class="arg-label">${n}</span>` : A}
+        <select
+          class="symbol-select"
+          @change=${(e) => this.#t(t, e.currentTarget.value)}
+        >
+          ${this.symbols.map((e) => O`<option value=${e.id} ?selected=${e.id === s.id}>${e.label}</option>`)}
+        </select>
+        ${this.#d(t, i, r)}
+      </span>` : O`<span class="slot slot-leaf" data-kind="symbol" data-path=${a}>
+          ${n ? O`<span class="arg-label">${n}</span>` : A}
+          <span class="symbol-chip" tabindex="0" title=${s.id}>${s.label}</span>
+        </span>`;
+		}
+		if (!o) {
+			let t = i === "number" ? String(e) : i === "boolean" ? e ? "true" : "false" : e;
+			return O`<span class="slot slot-leaf" data-kind=${i} data-path=${a}>
+        ${n ? O`<span class="arg-label">${n}</span>` : A}
+        <span class="value-text" tabindex="0">${t || A}</span>
+      </span>`;
+		}
+		let s;
+		return s = i === "number" ? O`<input
+        type="number"
+        .valueAsNumber=${e}
+        @change=${(e) => this.#t(t, e.currentTarget.valueAsNumber)}
+      />` : i === "boolean" ? O`<button
+        class="bool-toggle"
+        @click=${() => this.#t(t, !e)}
+      >
+        ${e ? "true" : "false"}
+      </button>` : O`<input
+        type="text"
+        .value=${e}
+        @change=${(e) => this.#t(t, e.currentTarget.value)}
+      />`, O`<span class="slot slot-leaf active" data-kind=${i} data-path=${a}>
+      ${n ? O`<span class="arg-label">${n}</span>` : A}
+      ${s}
+      ${this.#d(t, i, r)}
+    </span>`;
+	}
+	#d(e, t, n) {
+		let r = t === "symbol" ? O`<button
+            class="menu-item"
+            @click=${(t) => {
+			this.#t(e, ""), Q(t.currentTarget);
+		}}
+          >
+            Convert to literal
+          </button>` : O`<button
+            class="menu-item"
+            @click=${(n) => {
+			this.#f(e, t), Q(n.currentTarget);
+		}}
+          >
+            Change type
+          </button>`;
+		return O`<details class="picker menu" @click=${(e) => e.stopPropagation()}>
+      <summary title="Actions">&hellip;</summary>
+      <div class="popover menu-popover">
+        <div class="menu-header">${et[t]}</div>
+        ${r}
+        ${this.symbols.length ? this.#N(e) : A}
+        ${this.#P(e)}
+        ${this.#F(e)}
+        ${n ? O`<button
+              class="menu-item danger"
+              @click=${(t) => {
+			this.#r(e), Q(t.currentTarget);
+		}}
+            >
+              Remove
+            </button>` : A}
+      </div>
+    </details>`;
+	}
+	#f(e, t) {
+		let n = [
+			"number",
+			"text",
+			"boolean"
+		], r = n[(n.indexOf(t) + 1) % n.length], i = r === "number" ? 0 : r !== "text" || "";
+		this.#t(e, i);
+	}
+	#p(e, t, n) {
+		let r = e[0];
+		if (r === "Constants" && e.length >= 2) return this.#h(e, t, n);
+		if (r === "If" && e.length >= 3) return this.#v(e, t, n);
+		let i = Je(r);
+		return i && Qe(r, i, e) ? this.#S(r, i, e, t, n) : this.#m(r, e, t, n);
+	}
+	#m(e, t, n, r) {
+		let i = q(e), a = t.slice(1), o = Xe(e), s = i?.args?.at(-1)?.variadic ?? !1, c = !o || a.length < o.max ? () => this.#t(n, W(t, 0)) : void 0, l = (e) => o ? a.length <= o.min ? !1 : s || e === a.length - 1 : !0, u = Z(n), d = this.activePath === u;
+		return O`<span class="node construct generic" tabindex="0" data-path=${u}>
+      <span class="construct-header">
+        <span class="construct-name">${e}</span>
+        ${i ? O`<span class="construct-category">${Ye(i.category)}</span>` : A}
+        ${d ? this.#A(e, n, r, c) : A}
+      </span>
+      <span class="construct-args">
+        ${a.map((e, t) => this.#u(e, [...n, t + 1], i?.args?.[t]?.label, l(t)))}
+      </span>
+    </span>`;
+	}
+	#h(e, t, n) {
+		let r = e.slice(1, -1), i = e.length - 1, a = e[i], o = () => {
+			let n = it(r);
+			this.#t(t, [
+				...e.slice(0, -1),
+				[n, 0],
+				e[i]
+			]);
+		}, s = Z(t);
+		return O`<span class="node construct generic constants" tabindex="0" data-path=${s}>
+      <span class="construct-header">
+        <span class="construct-name">Constants</span>
+        ${this.activePath === s ? this.#A("Constants", t, n, o, "Add constant") : A}
+      </span>
+      <span class="constants-bindings">
+        ${r.map((e, n) => this.#g(e, [...t, n + 1]))}
+      </span>
+      <span class="constants-final">
+        <span class="arg-label">result</span>
+        ${this.#u(a, [...t, i], void 0, !1)}
+      </span>
+    </span>`;
+	}
+	#g(e, t) {
+		if (!Array.isArray(e) || e.length !== 2 || typeof e[0] != "string") return this.#u(e, t, void 0, !0);
+		let [n, r] = e, i = [...t, 0], a = [...t, 1], o = Z(t), s = !this.expandedConstants.has(o);
+		return O`<span class="constant-card">
+      <span class="constant-header">
+        <button
+          class="fold-toggle"
+          title=${s ? "Expand" : "Collapse"}
+          @click=${() => this.#e(o)}
+        >
+          ${s ? "▸" : "▾"}
+        </button>
+        ${this.#_(n, i)}
+        <button
+          class="small-remove"
+          title="Remove this constant"
+          @click=${() => this.#r(t)}
+        >
+          &times;
+        </button>
+      </span>
+      ${s ? A : O`<span class="constant-value">${this.#u(r, a, void 0, !1)}</span>`}
+    </span>`;
+	}
+	#_(e, t) {
+		let n = Z(t);
+		return this.activePath === n ? O`<span class="slot slot-leaf active constant-name" data-path=${n}>
+      <input
+        type="text"
+        .value=${e}
+        @change=${(e) => this.#t(t, e.currentTarget.value)}
+      />
+    </span>` : O`<span class="slot slot-leaf constant-name" data-path=${n}>
+        <span class="value-text" tabindex="0">${e}</span>
+      </span>`;
+	}
+	#v(e, t, n) {
+		return at(e[1]) ? this.#y(e, t, n) : this.#b(e, t, n);
+	}
+	#y(e, t, n) {
+		let r = e.length === 4, i = [r ? A : O`<button
+            class="menu-item"
+            @click=${(n) => {
+			this.#t(t, W(e, 0)), Q(n.currentTarget);
+		}}
+          >
+            Add else
+          </button>`, O`<button
+        class="menu-item"
+        @click=${(n) => {
+			let i = e[1], a = e[2], o = r ? e[3] : 0;
+			this.#t(t, [
+				"If",
+				[i, a],
+				[!0, 0],
+				o
+			]), Q(n.currentTarget);
+		}}
+      >
+        Add elseif
+      </button>`], a = Z(t);
+		return O`<span class="node construct generic if-block" tabindex="0" data-path=${a}>
+      <span class="construct-header">
+        <span class="construct-name">If</span>
+        ${this.activePath === a ? this.#j("If", t, n, i) : A}
+      </span>
+      <span class="if-branches">
+        <span class="if-row">
+          <span class="if-keyword">if</span>
+          ${this.#u(e[1], [...t, 1], void 0, !1)}
+        </span>
+        <span class="if-row">
+          <span class="if-keyword">then</span>
+          ${this.#u(e[2], [...t, 2], void 0, !1)}
+        </span>
+        ${r ? O`<span class="if-row">
+              <span class="if-keyword">else</span>
+              ${this.#u(e[3], [...t, 3], void 0, !0)}
+            </span>` : A}
+      </span>
+    </span>`;
+	}
+	#b(e, t, n) {
+		let r = e.slice(1, -1), i = e.length - 1, a = r.length > 1, o = [O`<button
+        class="menu-item"
+        @click=${(n) => {
+			this.#t(t, [
+				...e.slice(0, -1),
+				[!0, 0],
+				e[i]
+			]), Q(n.currentTarget);
+		}}
+      >
+        Add elseif
+      </button>`], s = Z(t);
+		return O`<span class="node construct generic if-block" tabindex="0" data-path=${s}>
+      <span class="construct-header">
+        <span class="construct-name">If</span>
+        ${this.activePath === s ? this.#j("If", t, n, o) : A}
+      </span>
+      <span class="if-branches">
+        ${r.map((e, n) => this.#x(e, [...t, n + 1], n === 0, a))}
+        <span class="if-row">
+          <span class="if-keyword">else</span>
+          ${this.#u(e[i], [...t, i], void 0, !1)}
+        </span>
+      </span>
+    </span>`;
+	}
+	#x(e, t, n, r) {
+		if (!Array.isArray(e) || e.length !== 2) return O`<span class="if-row">${this.#u(e, t, void 0, r)}</span>`;
+		let [i, a] = e;
+		return O`<span class="if-row">
+      <span class="if-keyword">${n ? "if" : "else if"}</span>
+      ${this.#u(i, [...t, 0], void 0, !1)}
+      <span class="if-keyword">then</span>
+      ${this.#u(a, [...t, 1], void 0, !1)}
+      ${r ? O`<button
+            class="small-remove"
+            title="Remove this branch"
+            @click=${() => this.#r(t)}
+          >
+            &times;
+          </button>` : A}
+    </span>`;
+	}
+	#S(e, t, n, r, i) {
+		switch (t.kind) {
+			case "infix": return this.#C(e, t, n, r, i);
+			case "fraction": return this.#w(e, n, r, i);
+			case "power": return this.#T(e, n, r, i);
+			case "sqrt":
+			case "root": return this.#E(e, n, r, i);
+			case "reducer": return this.#D(e, t, n, r, i);
+			case "comparison": return this.#O(e, t, n, r, i);
+			case "array": return this.#k(e, n, r, i);
+		}
+	}
+	#C(e, t, n, r, i) {
+		let a = n.slice(1), o = typeof a[0] == "boolean", s = () => this.#t(r, W(n, o ? !0 : 0)), c = a.length > 2, l = Z(r), u = this.activePath === l, d = (e === "And" || e === "Or") && a.length > this.inlineToStackedThreshold, f = a.map((e, n) => O`
+        ${n > 0 ? O`<span class="op">${t.symbol}</span>` : A}
+        ${this.#u(e, [...r, n + 1], void 0, c)}
+      `);
+		return O`<span class="node construct infix" tabindex="0" data-path=${l}>
+      <span class="${d ? "infix-stacked" : "infix-row"}">
+        ${d ? f.map((e) => O`<span class="infix-stacked-row">${e}</span>`) : f}
+      </span>
+      ${u ? this.#A(e, r, i, s) : A}
+    </span>`;
+	}
+	#w(e, t, n, r) {
+		let i = Z(n), a = this.activePath === i;
+		return O`<span class="node construct fraction" tabindex="0" data-path=${i}>
+      <span class="frac">
+        <span class="frac-num">${this.#u(t[1], [...n, 1], void 0, !1)}</span>
+        <span class="frac-line"></span>
+        <span class="frac-den">${this.#u(t[2], [...n, 2], void 0, !1)}</span>
+      </span>
+      ${a ? this.#A(e, n, r, void 0) : A}
+    </span>`;
+	}
+	#T(e, t, n, r) {
+		let i = e === "Square", a = t[1], o = B(a), s = Z(n), c = this.activePath === s;
+		return O`<span class="node construct power" tabindex="0" data-path=${s}>
+      <span class="power-frame">
+        <span class="power-base">
+          ${o ? tt : A}${this.#u(a, [...n, 1], void 0, !1)}${o ? nt : A}
+        </span>
+        <span class="power-exp">
+          ${i ? O`<span class="literal-exp">2</span>` : this.#u(t[2], [...n, 2], void 0, !1)}
+        </span>
+      </span>
+      ${c ? this.#A(e, n, r, void 0) : A}
+    </span>`;
+	}
+	#E(e, t, n, r) {
+		let i = e === "Root", a = Z(n), o = this.activePath === a;
+		return O`<span class="node construct radical" tabindex="0" data-path=${a}>
+      <span class="radical-frame">
+        ${i ? O`<span class="radical-degree">${this.#u(t[2], [...n, 2], void 0, !1)}</span>` : A}
+        ${rt}
+        <span class="radical-sign">
+          <span class="radicand">${this.#u(t[1], [...n, 1], void 0, !1)}</span>
+        </span>
+      </span>
+      ${o ? this.#A(e, n, r, void 0) : A}
+    </span>`;
+	}
+	#D(e, t, n, r, i) {
+		let a = n[1], o = a !== void 0 && B(a) && a[0] === "Array", s = o ? [...r, 1] : r, c = o ? n[1] : n, l = c.slice(1), u = () => this.#t(s, W(c, 0)), d = l.length > +!o, f = Z(r), ee = this.activePath === f;
+		return O`<span class="node construct reducer" tabindex="0" data-path=${f}>
+      <span class="reducer-symbol">${t.symbol}</span>(<span class="reducer-args">
+        ${l.map((e, t) => O`
+            ${t > 0 ? O`<span class="comma">, </span>` : A}
+            ${this.#u(e, [...s, t + 1], void 0, d)}
+          `)}
+      </span>)
+      ${ee ? this.#A(e, r, i, u) : A}
+    </span>`;
+	}
+	#O(e, t, n, r, i) {
+		let a = Z(r), o = this.activePath === a;
+		return O`<span class="node construct comparison" tabindex="0" data-path=${a}>
+      ${this.#u(n[1], [...r, 1], void 0, !1)}
+      <span class="op">${t.symbol}</span>
+      ${this.#u(n[2], [...r, 2], void 0, !1)}
+      ${o ? this.#A(e, r, i, void 0) : A}
+    </span>`;
+	}
+	#k(e, t, n, r) {
+		let i = t.slice(1), a = () => this.#t(n, W(t, 0)), o = Z(n), s = this.activePath === o;
+		return O`<span class="node construct array-list" tabindex="0" data-path=${o}
+      >(<span class="list-elements">
+        ${i.map((e, t) => O`
+            ${t > 0 ? O`<span class="comma">, </span>` : A}
+            ${this.#u(e, [...n, t + 1], void 0, !0)}
+          `)}
+      </span>)${s ? this.#A(e, n, r, a) : A}
+    </span>`;
+	}
+	#A(e, t, n, r, i = "Add argument") {
+		let a = r ? [O`<button
+            class="menu-item"
+            @click=${(e) => {
+			r(), Q(e.currentTarget);
+		}}
+          >
+            ${i}
+          </button>`] : [];
+		return this.#j(e, t, n, a);
+	}
+	#j(e, t, n, r) {
+		return O`<details class="picker menu construct-menu" open @click=${(e) => e.stopPropagation()}>
+      <summary title="Actions">&hellip;</summary>
+      <div class="popover menu-popover">
+        <div class="menu-header">${J(e)}</div>
+        ${r}
+        ${this.symbols.length ? this.#N(t, "Replace with symbol…") : A}
+        ${this.#P(t)}
+        ${this.#M(e, t)}
+        ${this.#F(t)}
+        ${n ? O`<button
+              class="menu-item danger"
+              @click=${(e) => {
+			this.#r(t), Q(e.currentTarget);
+		}}
+            >
+              Remove
+            </button>` : A}
+      </div>
+    </details>`;
+	}
+	#M(e, t) {
+		let n = Ve(e), r = He(e);
+		if (n.length === 0 && !r) return A;
+		let i = (n, r) => {
+			this.value = Me(this.value, t, r, We(e, r)), this.#n(), Q(n.currentTarget);
+		};
+		return O`<details class="submenu">
+      <summary>Change operator&hellip;</summary>
+      <span class="popover operator-menu">
+        <span class="operator-grid">
+          ${n.map((e) => O`<button
+              class="operator-btn"
+              title=${J(e)}
+              @click=${(t) => i(t, e)}
+            >
+              ${Ge(e)}
+            </button>`)}
+          ${r ? O`
+                <button
+                  class="operator-btn"
+                  title="Always true"
+                  @click=${(e) => {
+			this.#t(t, !0), Q(e.currentTarget);
+		}}
+                >
+                  true
+                </button>
+                <button
+                  class="operator-btn"
+                  title="Always false"
+                  @click=${(e) => {
+			this.#t(t, !1), Q(e.currentTarget);
+		}}
+                >
+                  false
+                </button>
+              ` : A}
+        </span>
+        ${r ? O`
+              <button
+                class="menu-item"
+                @click=${(e) => {
+			let n = H(this.value, t).slice(1);
+			this.#t(t, [
+				"Element",
+				n[0] ?? 0,
+				[
+					"Interval",
+					n[1] ?? 0,
+					0
+				]
+			]), Q(e.currentTarget);
+		}}
+              >
+                In range&hellip;
+              </button>
+              <button
+                class="menu-item"
+                @click=${(e) => {
+			let n = H(this.value, t).slice(1);
+			this.#t(t, [
+				"NotElement",
+				n[0] ?? 0,
+				[
+					"Interval",
+					n[1] ?? 0,
+					0
+				]
+			]), Q(e.currentTarget);
+		}}
+              >
+                Not in range&hellip;
+              </button>
+            ` : A}
+      </span>
+    </details>`;
+	}
+	#N(e, t = "Insert symbol…") {
+		let n = `mjtb-sym-${Z(e)}`;
+		return O`<details class="submenu">
+      <summary>${t}</summary>
+      <span class="popover">
+        <input
+          type="search"
+          list=${n}
+          placeholder="Symbol…"
+          @change=${(t) => {
+			let n = t.currentTarget, r = this.symbols.find((e) => e.label === n.value);
+			r && this.#t(e, r.id), n.value = "", Q(n);
+		}}
+        />
+        <datalist id=${n}>
+          ${this.symbols.map((e) => O`<option value=${e.label}></option>`)}
+        </datalist>
+      </span>
+    </details>`;
+	}
+	#P(e) {
+		let t = `mjtb-fn-${Z(e)}`;
+		return O`<details class="submenu">
+      <summary>Turn into function&hellip;</summary>
+      <span class="popover">
+        <input
+          type="search"
+          list=${t}
+          placeholder="Function…"
+          @change=${(t) => {
+			let n = t.currentTarget, r = n.value;
+			q(r) && !this.blacklist.includes(r) && this.#t(e, [r, ...Y(r)]), n.value = "", Q(n);
+		}}
+        />
+        <datalist id=${t}>
+          ${Ze("", this.blacklist).map((e) => O`<option value=${e.name}></option>`)}
+        </datalist>
+      </span>
+    </details>`;
+	}
+	#F(e) {
+		let t = `mjtb-wrap-${Z(e)}`;
+		return O`<details class="submenu">
+      <summary>Wrap in&hellip;</summary>
+      <span class="popover">
+        <input
+          type="search"
+          list=${t}
+          placeholder="Wrap in…"
+          @change=${(t) => {
+			let n = t.currentTarget, r = n.value;
+			if (q(r) && !this.blacklist.includes(r)) {
+				let t = Y(r).slice(1);
+				this.value = je(this.value, e, r, t), this.#n();
+			}
+			n.value = "", Q(n);
+		}}
+        />
+        <datalist id=${t}>
+          ${Ze("", this.blacklist).map((e) => O`<option value=${e.name}></option>`)}
+        </datalist>
+      </span>
+    </details>`;
+	}
+};
+X([R({ attribute: !1 })], $.prototype, "value", void 0), X([R({ attribute: !1 })], $.prototype, "symbols", void 0), X([R({ attribute: !1 })], $.prototype, "blacklist", void 0), X([R({ attribute: !1 })], $.prototype, "evaluate", void 0), X([R({
+	type: Number,
+	attribute: "inline-to-stacked-threshold"
+})], $.prototype, "inlineToStackedThreshold", void 0), X([z()], $.prototype, "activePath", void 0), X([z()], $.prototype, "jsonMode", void 0), X([z()], $.prototype, "jsonDraft", void 0), X([z()], $.prototype, "jsonError", void 0), X([z()], $.prototype, "expandedConstants", void 0), customElements.get("mathjson-tree-builder") || customElements.define("mathjson-tree-builder", $);
+//#endregion
+export { Fe as CATEGORY_LABELS, $ as MathJsonTreeBuilderElement, qe as allConstructs, Xe as argBounds, Ye as categoryLabel, Y as defaultArgsFor, J as displayName, H as getAtPath, q as getConstruct, Je as getNotation, He as isComparisonLike, B as isCompound, V as isValidMathJson, Ge as operatorGlyph, G as resolveSymbol, Ze as searchConstructs, Ne as searchSymbols, U as setAtPath, We as swapNeedsArgReversal, Me as swapOperator, Ve as swapTargets, W as withArgAdded, Ae as withArgRemoved, je as wrapAtPath };
+
+//# sourceMappingURL=mathjson-tree-builder.js.map