@drghaliasri/butex 5.5.5 → 5.6.0

package/dist/react.mjs

@@ -127,6 +127,81 @@ function cloneEditorSession(session) {
     debugLog: session.debugLog.slice()
   };
 }
+function collectNodeIds(chain, ids) {
+  for (const node of chain.nodes) {
+    ids.push(node.id);
+    if (node.superscript) {
+      collectNodeIds(node.superscript, ids);
+    }
+    if (node.subscript) {
+      collectNodeIds(node.subscript, ids);
+    }
+    if (node.innerExpr) {
+      collectNodeIds(node.innerExpr, ids);
+    }
+    if (node.numerator) {
+      collectNodeIds(node.numerator, ids);
+    }
+    if (node.denominator) {
+      collectNodeIds(node.denominator, ids);
+    }
+    if (node.rootIndex) {
+      collectNodeIds(node.rootIndex, ids);
+    }
+    if (node.radicand) {
+      collectNodeIds(node.radicand, ids);
+    }
+    if (node.overExpr) {
+      collectNodeIds(node.overExpr, ids);
+    }
+    if (node.underExpr) {
+      collectNodeIds(node.underExpr, ids);
+    }
+    if (node.baseExpr) {
+      collectNodeIds(node.baseExpr, ids);
+    }
+    if (node.matrixRows) {
+      for (const row of node.matrixRows) {
+        for (const cell of row) {
+          collectNodeIds(cell, ids);
+        }
+      }
+    }
+  }
+}
+function buildInitialSyncMap(englishTree, arabicTree) {
+  const englishIds = [];
+  const arabicIds = [];
+  collectNodeIds(englishTree, englishIds);
+  collectNodeIds(arabicTree, arabicIds);
+  const all = /* @__PURE__ */ new Set([...englishIds, ...arabicIds]);
+  const sync = {};
+  for (const nodeId of all) {
+    sync[nodeId] = { expr: "synced" };
+  }
+  return sync;
+}
+function createEditorSession(englishTree, arabicTree, activeSide = "arabic") {
+  return {
+    englishTree,
+    arabicTree,
+    activeSide,
+    splitLeafTyping: false,
+    forceSplitNextLeaf: false,
+    arabicReverseNumberTyping: true,
+    currentCharacterFont: "default",
+    currentDigitForm: "western",
+    caret: {
+      chainId: englishTree.id,
+      index: 0
+    },
+    selection: null,
+    selectedNodeId: null,
+    selectedStructureNodeId: null,
+    sync: buildInitialSyncMap(englishTree, arabicTree),
+    debugLog: []
+  };
+}
 
 // src/editor/accentCommands.ts
 var ACCENT_COMMANDS = {
@@ -265,6 +340,20 @@ function accentCommandSpec(id) {
 function accentCommandsList() {
   return Object.values(ACCENT_COMMANDS);
 }
+function accentCommandIdFromTex(tex) {
+  const normalized = tex.startsWith("\\") ? tex : `\\${tex}`;
+  for (const spec of Object.values(ACCENT_COMMANDS)) {
+    if (spec.englishTex === normalized) {
+      return spec.id;
+    }
+  }
+  for (const spec of Object.values(ACCENT_COMMANDS)) {
+    if (spec.arabicTex === normalized) {
+      return spec.id;
+    }
+  }
+  return null;
+}
 
 // src/editor/atomicCommands.ts
 var ATOMIC_COMMANDS = {
@@ -687,6 +776,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators1",
     Tex: "\\neq",
     mirror: true,
+    compileMirror: true,
     Label: "\u2260",
     title: "\u0644\u0627 \u064A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -726,6 +816,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\leq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2264",
     title: "\u0623\u0635\u063A\u0631 \u0645\u0646 \u0623\u0648 \u064A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -736,6 +827,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\geq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2265",
     title: "\u0623\u0643\u0628\u0631 \u0645\u0646 \u0623\u0648 \u064A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -746,6 +838,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\coloneqq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2254",
     title: "\u064A\u0639\u0631\u0641 \u0628\u0623\u0646\u0647 \u064A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -756,6 +849,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\eqqcolon",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2255",
     title: "\u064A\u0633\u0627\u0648\u064A \u0628\u0627\u0644\u062A\u0639\u0631\u064A\u0641",
     svg_path: null
@@ -767,6 +861,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\propto",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u221D",
     title: "\u064A\u062A\u0646\u0627\u0633\u0628 \u0645\u0639",
     svg_path: null
@@ -777,6 +872,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\in",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2208",
     title: "\u064A\u0646\u062A\u0645\u064A \u0625\u0644\u0649",
     svg_path: null
@@ -797,6 +893,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\subset",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2282",
     title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u062C\u0632\u0626\u064A\u0629 \u0645\u0646",
     svg_path: null
@@ -807,6 +904,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\supset",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2283",
     title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u0634\u0627\u0645\u0644\u0629 \u0644\u0640",
     svg_path: null
@@ -817,6 +915,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\subseteq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2286",
     title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u062C\u0632\u0626\u064A\u0629 \u0623\u0648 \u062A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -827,6 +926,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\supseteq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2287",
     title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u0634\u0627\u0645\u0644\u0629 \u0623\u0648 \u062A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -867,6 +967,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\nsubseteq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2288",
     title: "\u0644\u064A\u0633\u062A \u0645\u062C\u0645\u0648\u0639\u0629 \u062C\u0632\u0626\u064A\u0629 \u0623\u0648 \u062A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -877,6 +978,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\nsupseteq",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2289",
     title: "\u0644\u064A\u0633\u062A \u0645\u062C\u0645\u0648\u0639\u0629 \u0634\u0627\u0645\u0644\u0629 \u0623\u0648 \u062A\u0633\u0627\u0648\u064A",
     svg_path: null
@@ -924,6 +1026,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\ddots",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u22F1",
     title: "\u0646\u0642\u0627\u0637 \u0642\u0637\u0631\u064A\u0629",
     svg_path: null
@@ -943,6 +1046,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\implies",
     mirror: true,
+    compileMirror: true,
     Label: "\u21D2",
     title: "\u064A\u0633\u062A\u0644\u0632\u0645",
     svg_path: null
@@ -952,6 +1056,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\impliedby",
     mirror: true,
+    compileMirror: true,
     Label: "\u21D0",
     title: "\u0645\u0633\u062A\u0644\u0632\u0645 \u0645\u0646",
     svg_path: null
@@ -970,6 +1075,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\Longrightarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u27F9",
     title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0637\u0648\u064A\u0644 \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
     svg_path: null
@@ -979,6 +1085,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\Longleftarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u27F8",
     title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0637\u0648\u064A\u0644 \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
     svg_path: null
@@ -988,6 +1095,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\to",
     mirror: true,
+    compileMirror: true,
     Label: "\u2192",
     title: "\u064A\u0624\u0648\u0644 \u0625\u0644\u0649",
     svg_path: null
@@ -997,6 +1105,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\rightleftharpoons",
     mirror: true,
+    compileMirror: true,
     Label: "\u21CC",
     title: "\u0627\u062A\u0632\u0627\u0646",
     svg_path: null
@@ -1006,6 +1115,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\leftarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u2190",
     title: "\u0633\u0647\u0645 \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
     svg_path: null
@@ -1015,6 +1125,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\rightarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u2192",
     title: "\u0633\u0647\u0645 \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
     svg_path: null
@@ -1024,6 +1135,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\Leftarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u21D0",
     title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
     svg_path: null
@@ -1033,6 +1145,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\Rightarrow",
     mirror: true,
+    compileMirror: true,
     Label: "\u21D2",
     title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
     svg_path: null
@@ -1042,6 +1155,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\leftharpoonup",
     mirror: true,
+    compileMirror: true,
     Label: "\u21BC",
     title: "\u0633\u0647\u0645 \u062E\u0637\u0627\u0641\u064A \u0639\u0644\u0648\u064A \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
     svg_path: null
@@ -1051,6 +1165,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\rightharpoonup",
     mirror: true,
+    compileMirror: true,
     Label: "\u21C0",
     title: "\u0633\u0647\u0645 \u062E\u0637\u0627\u0641\u064A \u0639\u0644\u0648\u064A \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
     svg_path: null
@@ -1060,6 +1175,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\leftharpoondown",
     mirror: true,
+    compileMirror: true,
     Label: "\u21BD",
     title: "\u0633\u0647\u0645 \u062E\u0637\u0627\u0641\u064A \u0633\u0641\u0644\u064A \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
     svg_path: null
@@ -1069,6 +1185,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "operators3",
     Tex: "\\rightharpoondown",
     mirror: true,
+    compileMirror: true,
     Label: "\u21C1",
     title: "\u0633\u0647\u0645 \u062E\u0637\u0627\u0641\u064A \u0633\u0641\u0644\u064A \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
     svg_path: null
@@ -1079,6 +1196,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     category: "integrals",
     Tex: "\\int",
     mirror: true,
+    compileMirror: true,
     Label: "\u222B",
     title: "\u062A\u0643\u0627\u0645\u0644",
     svg_path: null
@@ -1089,6 +1207,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\iint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u222C",
     title: "\u062A\u0643\u0627\u0645\u0644 \u0645\u0632\u062F\u0648\u062C",
     svg_path: null
@@ -1099,6 +1218,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\iiint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u222D",
     title: "\u062A\u0643\u0627\u0645\u0644 \u062B\u0644\u0627\u062B\u064A",
     svg_path: null
@@ -1109,6 +1229,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\iiiint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2A0C",
     title: "\u062A\u0643\u0627\u0645\u0644 \u0631\u0628\u0627\u0639\u064A",
     svg_path: null
@@ -1119,6 +1240,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\oint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u222E",
     title: "\u062A\u0643\u0627\u0645\u0644 \u0645\u063A\u0644\u0642",
     svg_path: null
@@ -1129,6 +1251,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\oiint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u222F",
     title: "\u062A\u0643\u0627\u0645\u0644 \u0633\u0637\u062D\u064A \u0645\u063A\u0644\u0642",
     svg_path: null
@@ -1139,6 +1262,7 @@ var ATOMIC_OPERATOR_COMMANDS = {
     Tex: "\\oiiint",
     mirror: true,
     displayMirror: false,
+    compileMirror: true,
     Label: "\u2230",
     title: "\u062A\u0643\u0627\u0645\u0644 \u062D\u062C\u0645\u064A \u0645\u063A\u0644\u0642",
     svg_path: null
@@ -1148,8 +1272,9 @@ function shouldMirrorOperatorDisplay(command) {
   return command?.displayMirror ?? command?.mirror ?? false;
 }
 var MIRRORED_OPERATOR_TEX = Object.values(ATOMIC_OPERATOR_COMMANDS).filter((command) => command.mirror).map((command) => command.Tex).sort((a, b) => b.length - a.length);
-function matchingMirroredOperator(tex, index) {
-  for (const operatorTex of MIRRORED_OPERATOR_TEX) {
+var COMPILE_MIRRORED_OPERATOR_TEX = Object.values(ATOMIC_OPERATOR_COMMANDS).filter((command) => "compileMirror" in command && command.compileMirror).map((command) => command.Tex).sort((a, b) => b.length - a.length);
+function matchingMirroredOperatorFrom(tex, index, operatorTexList) {
+  for (const operatorTex of operatorTexList) {
     if (!tex.startsWith(operatorTex, index)) {
       continue;
     }
@@ -1180,19 +1305,26 @@ function findMatchingBrace(tex, openIndex) {
   }
   return -1;
 }
-function mirrorBuTeXOperatorsInTex(tex) {
+function mirrorBuTeXOperatorsInTex(tex, options = {}) {
+  const mirroredOperatorTex = options.target === "compile" ? COMPILE_MIRRORED_OPERATOR_TEX : MIRRORED_OPERATOR_TEX;
   let result = "";
   let index = 0;
   while (index < tex.length) {
     if (tex.startsWith("\\butexmirror{", index)) {
       const end = findMatchingBrace(tex, index + "\\butexmirror".length);
       if (end !== -1) {
-        result += tex.slice(index, end + 1);
+        const bodyStart = index + "\\butexmirror{".length;
+        const body = tex.slice(bodyStart, end);
+        if (options.target === "compile" && MIRRORED_OPERATOR_TEX.includes(body) && !mirroredOperatorTex.includes(body)) {
+          result += body;
+        } else {
+          result += tex.slice(index, end + 1);
+        }
         index = end + 1;
         continue;
       }
     }
-    const operatorTex = matchingMirroredOperator(tex, index);
+    const operatorTex = matchingMirroredOperatorFrom(tex, index, mirroredOperatorTex);
     if (operatorTex) {
       result += `\\butexmirror{${operatorTex}}`;
       index += operatorTex.length;
@@ -6865,6 +6997,11 @@ var WIDGET_CHROME_CSS = `
   font-family: ${BUTEX_DIWANI_OUTLINE_FONT_STACK};
 }
 
+.butex-widget .font-mode-btn--maghribi,
+.butex-widget .character-font-option--maghribi {
+  font-family: ${BUTEX_MAGHRIBI_FONT_STACK};
+}
+
 .butex-widget .character-font-options {
   position: absolute;
   z-index: 10;
@@ -7399,6 +7536,36 @@ var WIDGET_CHROME_CSS = `
   background: var(--butex-dev-inset-bg);
   color: var(--butex-dev-inset-fg);
 }
+
+.butex-widget .debug-json-import {
+  display: grid;
+  gap: 8px;
+  margin-bottom: 10px;
+}
+
+.butex-widget .debug-json-import textarea {
+  min-height: 150px;
+  resize: vertical;
+  border: 1px solid var(--butex-dev-inset-border);
+  border-radius: 8px;
+  padding: 8px 10px;
+  direction: ltr;
+  text-align: left;
+  font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+  font-size: 11px;
+  background: var(--butex-dev-inset-bg);
+  color: var(--butex-dev-inset-fg);
+}
+
+.butex-widget .debug-json-error {
+  margin: 0;
+  border: 1px solid rgba(220, 38, 38, 0.45);
+  background: rgba(254, 226, 226, 0.9);
+  color: #991b1b;
+  border-radius: 8px;
+  padding: 8px 10px;
+  white-space: pre-wrap;
+}
 `.trim();
 var CHROME_STYLE_ID = "butex-widget-chrome-css";
 function injectWidgetChromeCss(doc) {
@@ -7417,6 +7584,1026 @@ function uiLocaleDirection(locale) {
   return locale === "ar" ? "rtl" : "ltr";
 }
 
+// src/ast/commands/index.ts
+function renderCommandCore(context) {
+  const optional = context.optionalArgs.map((arg) => `[${context.renderChain(arg)}]`).join("");
+  const mandatory = context.mandatoryArgs.map((arg) => `{${context.renderChain(arg)}}`).join("");
+  return context.name + optional + mandatory;
+}
+
+// src/ast/arabic_ast.ts
+var State = class {
+  // Empty for now, like the Python State placeholder used by BaseNode.
+};
+var BaseAstNode = class {
+  state;
+  superscript;
+  subscript;
+  nodeType;
+  constructor(state = null) {
+    if (state === null) {
+      state = new State();
+    }
+    this.state = state;
+    this.superscript = null;
+    this.subscript = null;
+    this.nodeType = this.constructor.name;
+  }
+  latex() {
+    throw new Error("NotImplementedError");
+  }
+  arabicLatex() {
+    throw new Error("NotImplementedError");
+  }
+  toArabicLatex() {
+    return this.arabicLatex();
+  }
+  /** Latin-style scripts: `^{...}` and `_{...}` for english_json rendering. */
+  latexScripts() {
+    let s = "";
+    if (this.superscript !== null) {
+      s += "^{" + this.superscript.latex() + "}";
+    }
+    if (this.subscript !== null) {
+      s += "_{" + this.subscript.latex() + "}";
+    }
+    return s;
+  }
+  /**
+   * Arabic scripts use \\prescript{sup}{sub}{content} (matches reference Python output).
+   * Call with rendered strings for sup/sub chains (may be empty strings).
+   */
+  arabicLatexScripts(sup, sub, content) {
+    if (sup !== "" || sub !== "") {
+      return "\\prescript{" + sup + "}{" + sub + "}{" + content + "}";
+    }
+    return content;
+  }
+};
+var ChainNode = class {
+  chain;
+  constructor(chain = []) {
+    this.chain = chain;
+  }
+  latex() {
+    return this.chain.map((node) => node.latex()).join(" ");
+  }
+  toEnglishLatex() {
+    return this.chain.map((node) => node.latex()).join(" ");
+  }
+  /** RTL: reverse order relative to Latin chain (see test/ref_tests.txt). */
+  arabicLatex() {
+    const reversed = this.chain.slice().reverse();
+    return reversed.map((node) => node.arabicLatex()).join(" ");
+  }
+  toArabicLatex() {
+    return this.arabicLatex();
+  }
+};
+var NumberNode = class extends BaseAstNode {
+  expr;
+  constructor(expr, state = null) {
+    super(state);
+    this.nodeType = "NumberObject";
+    this.expr = expr;
+  }
+  latex() {
+    return this.expr + this.latexScripts();
+  }
+  arabicLatex() {
+    const sup = this.superscript !== null ? this.superscript.arabicLatex() : "";
+    const sub = this.subscript !== null ? this.subscript.arabicLatex() : "";
+    return this.arabicLatexScripts(sup, sub, this.expr);
+  }
+};
+var CharNode = class extends BaseAstNode {
+  expr;
+  constructor(expr, state = null) {
+    super(state);
+    this.nodeType = "CharObject";
+    this.expr = expr;
+  }
+  latex() {
+    return this.expr + this.latexScripts();
+  }
+  arabicLatex() {
+    const sup = this.superscript !== null ? this.superscript.arabicLatex() : "";
+    const sub = this.subscript !== null ? this.subscript.arabicLatex() : "";
+    return this.arabicLatexScripts(sup, sub, this.expr);
+  }
+};
+var OperatorNode = class extends BaseAstNode {
+  expr;
+  constructor(expr, state = null) {
+    super(state);
+    this.nodeType = "OperatorObject";
+    this.expr = expr;
+  }
+  latex() {
+    return this.expr;
+  }
+  arabicLatex() {
+    return this.expr;
+  }
+};
+var DelimiterNode = class extends BaseAstNode {
+  leftDelimExpr;
+  innerExpr;
+  rightDelimExpr;
+  constructor(leftDelimExpr, innerExpr, rightDelimExpr, state = null) {
+    super(state);
+    this.nodeType = "DelimiterObject";
+    this.leftDelimExpr = leftDelimExpr;
+    this.innerExpr = innerExpr;
+    this.rightDelimExpr = rightDelimExpr;
+  }
+  latex() {
+    return this.leftDelimExpr + this.innerExpr.latex() + this.rightDelimExpr + this.latexScripts();
+  }
+  arabicLatex() {
+    const sup = this.superscript !== null ? this.superscript.arabicLatex() : "";
+    const sub = this.subscript !== null ? this.subscript.arabicLatex() : "";
+    const content = this.leftDelimExpr + this.innerExpr.arabicLatex() + this.rightDelimExpr;
+    return this.arabicLatexScripts(sup, sub, content);
+  }
+};
+var CommandNode = class extends BaseAstNode {
+  name;
+  optionalArgs;
+  mandatoryArgs;
+  constructor(name, optionalArgs = [], mandatoryArgs = [], state = null) {
+    super(state);
+    this.nodeType = "CommandObject";
+    this.name = name;
+    this.optionalArgs = optionalArgs;
+    this.mandatoryArgs = mandatoryArgs;
+  }
+  latex() {
+    const content = renderCommandCore({
+      name: this.name,
+      optionalArgs: this.optionalArgs,
+      mandatoryArgs: this.mandatoryArgs,
+      renderChain: (chain) => chain.latex()
+    });
+    return content + this.latexScripts();
+  }
+  arabicLatex() {
+    const sup = this.superscript !== null ? this.superscript.arabicLatex() : "";
+    const sub = this.subscript !== null ? this.subscript.arabicLatex() : "";
+    const arabicName = this.name === "\\sqrt" || this.name === "\\arabsqrt" ? "\\arsqrt" : this.name;
+    const content = renderCommandCore({
+      name: arabicName,
+      optionalArgs: this.optionalArgs,
+      mandatoryArgs: this.mandatoryArgs,
+      renderChain: (chain) => chain.arabicLatex()
+    });
+    return this.arabicLatexScripts(sup, sub, content);
+  }
+};
+var EnvNode = class extends BaseAstNode {
+  opening;
+  lines;
+  closing;
+  constructor(opening, lines = [], closing, state = null) {
+    super(state);
+    this.nodeType = "EnvObject";
+    this.opening = opening;
+    this.lines = lines;
+    this.closing = closing;
+  }
+  latex() {
+    if (this.lines.length === 0) {
+      return this.opening + this.closing + this.latexScripts();
+    }
+    const formattedLines = this.lines.map((line) => `    ${line.latex()}`);
+    const content = formattedLines.join(" \\\\\n");
+    return `${this.opening}
+${content}
+${this.closing}` + this.latexScripts();
+  }
+  arabicLatex() {
+    const sup = this.superscript !== null ? this.superscript.arabicLatex() : "";
+    const sub = this.subscript !== null ? this.subscript.arabicLatex() : "";
+    if (this.lines.length === 0) {
+      return this.arabicLatexScripts(sup, sub, this.opening + this.closing);
+    }
+    const formattedLines = this.lines.map((line) => `    ${line.arabicLatex()}`);
+    const content = formattedLines.join(" \\\\\n");
+    const fullContent = `${this.opening}
+${content}
+${this.closing}`;
+    return this.arabicLatexScripts(sup, sub, fullContent);
+  }
+};
+function parseScripts(node, json, mode) {
+  if (json.superscript) {
+    node.superscript = parseChain(json.superscript, mode);
+  }
+  if (json.subscript) {
+    node.subscript = parseChain(json.subscript, mode);
+  }
+}
+function parseNode(json, mode) {
+  if (json.node_type === "DelimiterObject") {
+    const node2 = parseDelimiter(json, mode);
+    parseScripts(node2, json, mode);
+    return node2;
+  }
+  if (json.node_type === "OperatorObject") {
+    if (typeof json.expr !== "string") {
+      throw new Error("OperatorObject requires string expr");
+    }
+    const node2 = new OperatorNode(json.expr);
+    parseScripts(node2, json, mode);
+    return node2;
+  }
+  if (json.node_type === "CommandObject") {
+    const node2 = parseCommand(json, mode);
+    parseScripts(node2, json, mode);
+    return node2;
+  }
+  if (json.node_type === "EnvObject") {
+    const node2 = parseEnv(json, mode);
+    parseScripts(node2, json, mode);
+    return node2;
+  }
+  if (typeof json.expr !== "string") {
+    throw new Error(`${json.node_type} requires string expr`);
+  }
+  let node;
+  if (json.node_type === "NumberObject") {
+    node = new NumberNode(json.expr);
+  } else if (json.node_type === "CharObject") {
+    node = new CharNode(json.expr);
+  } else {
+    throw new Error(`Unsupported node_type: ${json.node_type}`);
+  }
+  parseScripts(node, json, mode);
+  return node;
+}
+function parseDelimiter(json, mode) {
+  if (typeof json.left_delim_expr !== "string") {
+    throw new Error("DelimiterObject requires string left_delim_expr");
+  }
+  if (!json.inner_expr || json.inner_expr.node_type !== "ChainClass") {
+    throw new Error("DelimiterObject requires ChainClass inner_expr");
+  }
+  if (typeof json.right_delim_expr !== "string") {
+    throw new Error("DelimiterObject requires string right_delim_expr");
+  }
+  const innerExpr = parseChain(json.inner_expr, mode);
+  return new DelimiterNode(json.left_delim_expr, innerExpr, json.right_delim_expr);
+}
+function parseCommand(json, mode) {
+  if (typeof json.name !== "string") {
+    throw new Error("CommandObject requires string name");
+  }
+  const optionalJson = Array.isArray(json.optional_args) ? json.optional_args : [];
+  const mandatoryJson = Array.isArray(json.mandatory_args) ? json.mandatory_args : [];
+  const optionalArgs = optionalJson.map((arg) => parseChain(arg, mode));
+  const mandatoryArgs = mandatoryJson.map((arg) => parseChain(arg, mode));
+  return new CommandNode(json.name, optionalArgs, mandatoryArgs);
+}
+function parseEnv(json, mode) {
+  if (typeof json.opening !== "string") {
+    throw new Error("EnvObject requires string opening");
+  }
+  if (typeof json.closing !== "string") {
+    throw new Error("EnvObject requires string closing");
+  }
+  if (!Array.isArray(json.lines)) {
+    throw new Error("EnvObject requires lines array");
+  }
+  const lines = json.lines.map((line) => parseChain(line, mode));
+  return new EnvNode(json.opening, lines, json.closing);
+}
+function parseChain(json, mode) {
+  if (json.node_type !== "ChainClass") {
+    throw new Error(`Expected ChainClass, got: ${json.node_type}`);
+  }
+  const nodes = json.chain.map((childJson) => parseNode(childJson, mode));
+  return new ChainNode(nodes);
+}
+function fromEnglishJson(json) {
+  if (json.node_type === "ChainClass") {
+    return parseChain(json, "english");
+  }
+  return parseNode(json, "english");
+}
+function fromArabicJson(json) {
+  if (json.node_type === "ChainClass") {
+    return parseChain(json, "arabic");
+  }
+  return parseNode(json, "arabic");
+}
+
+// src/document/mathObject.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isMathObjectJson(value) {
+  return isObject(value) && value.node_type === "MathObject";
+}
+function assertChainNode(value) {
+  if (!(value instanceof ChainNode)) {
+    throw new Error("MathObject lines must parse to ChainNode");
+  }
+  return value;
+}
+function fromMathObjectJson(json, mode = "english") {
+  if (!isMathObjectJson(json)) {
+    throw new Error('MathObject requires node_type "MathObject"');
+  }
+  if (typeof json.math_mode !== "string") {
+    throw new Error("MathObject requires string math_mode");
+  }
+  if (typeof json.closing !== "string") {
+    throw new Error("MathObject requires string closing");
+  }
+  if (!Array.isArray(json.lines) || json.lines.length === 0) {
+    throw new Error("MathObject requires non-empty lines array");
+  }
+  const parseChain2 = mode === "arabic" ? fromArabicJson : fromEnglishJson;
+  const lines = json.lines.map((line) => assertChainNode(parseChain2(line)));
+  return {
+    nodeType: "MathObject",
+    mathMode: json.math_mode,
+    lines,
+    closing: json.closing
+  };
+}
+function scriptsToJson(node, path) {
+  return {
+    ...node.superscript ? { superscript: chainToJson(node.superscript, `${path}.superscript`) } : {},
+    ...node.subscript ? { subscript: chainToJson(node.subscript, `${path}.subscript`) } : {}
+  };
+}
+function nodeToJson(node, path) {
+  const scripts = scriptsToJson(node, path);
+  if (node instanceof CharNode || node instanceof NumberNode || node instanceof OperatorNode) {
+    return { node_type: node.nodeType, expr: node.expr, ...scripts };
+  }
+  if (node instanceof DelimiterNode) {
+    return {
+      node_type: "DelimiterObject",
+      left_delim_expr: node.leftDelimExpr,
+      inner_expr: chainToJson(node.innerExpr, `${path}.inner_expr`),
+      right_delim_expr: node.rightDelimExpr,
+      ...scripts
+    };
+  }
+  if (node instanceof CommandNode) {
+    return {
+      node_type: "CommandObject",
+      name: node.name,
+      optional_args: node.optionalArgs.map((arg, index) => chainToJson(arg, `${path}.optional_args[${String(index)}]`)),
+      mandatory_args: node.mandatoryArgs.map((arg, index) => chainToJson(arg, `${path}.mandatory_args[${String(index)}]`)),
+      ...scripts
+    };
+  }
+  if (node instanceof EnvNode) {
+    return {
+      node_type: "EnvObject",
+      opening: node.opening,
+      lines: node.lines.map((line, index) => chainToJson(line, `${path}.lines[${String(index)}]`)),
+      closing: node.closing,
+      ...scripts
+    };
+  }
+  throw new Error(`Unsupported runtime math node at ${path}: ${node.nodeType}`);
+}
+function chainToJson(chain, path) {
+  if (!(chain instanceof ChainNode)) {
+    throw new Error(`Expected live ChainNode at ${path}`);
+  }
+  return {
+    node_type: "ChainClass",
+    chain: chain.chain.map((node, index) => nodeToJson(node, `${path}.chain[${String(index)}]`))
+  };
+}
+function toMathObjectJson(math) {
+  if (math.nodeType !== "MathObject" || !Array.isArray(math.lines) || math.lines.length === 0) {
+    throw new Error("Cannot serialize invalid runtime MathObject");
+  }
+  return {
+    node_type: "MathObject",
+    math_mode: math.mathMode,
+    lines: math.lines.map((line, index) => chainToJson(line, `$.lines[${String(index)}]`)),
+    closing: math.closing
+  };
+}
+
+// src/document/normalizeCharImport.ts
+var WRAPPER_SPECS = [
+  ...NON_DEFAULT_CHARACTER_FONT_SPECS.flatMap((font) => [
+    { prefix: font.macro, font: font.id },
+    ...(font.importAliases ?? []).map((alias) => ({ prefix: alias, font: font.id }))
+  ]),
+  { prefix: "\\text" }
+];
+function readBracedArg(source, openBraceIndex) {
+  if (source[openBraceIndex] !== "{") {
+    return null;
+  }
+  let depth = 0;
+  for (let index = openBraceIndex; index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "{") {
+      depth += 1;
+    } else if (char === "}") {
+      depth -= 1;
+      if (depth === 0) {
+        return { inner: source.slice(openBraceIndex + 1, index), end: index + 1 };
+      }
+    }
+  }
+  return null;
+}
+function peelWrapper(source) {
+  for (const wrapper of WRAPPER_SPECS) {
+    if (!source.startsWith(wrapper.prefix)) {
+      continue;
+    }
+    const braced = readBracedArg(source, wrapper.prefix.length);
+    if (!braced || braced.end !== source.length) {
+      continue;
+    }
+    return { inner: braced.inner, font: wrapper.font };
+  }
+  return null;
+}
+function normalizeCharImportExpr(expr) {
+  const original = expr;
+  let current = expr;
+  let characterFont = "default";
+  let changed = false;
+  while (true) {
+    const peeled = peelWrapper(current);
+    if (!peeled) {
+      break;
+    }
+    current = peeled.inner;
+    if (peeled.font) {
+      characterFont = peeled.font;
+    }
+    changed = true;
+  }
+  if (!changed) {
+    return { expr: original, characterFont: "default" };
+  }
+  if (current.includes("\\")) {
+    return { expr: original, characterFont: "default" };
+  }
+  return { expr: current, characterFont };
+}
+
+// src/document/mathEditorAdapter.ts
+var COMMAND_FONT_MAP = Object.fromEntries([
+  ["\\text", "infer"],
+  ...NON_DEFAULT_CHARACTER_FONT_SPECS.flatMap((font) => [
+    [font.macro, font.id],
+    ...(font.importAliases ?? []).map((alias) => [alias, font.id])
+  ])
+]);
+var CHAR_FONT_EXPORT_TEX = Object.fromEntries(
+  NON_DEFAULT_CHARACTER_FONT_SPECS.map((font) => [font.id, font.macro])
+);
+function charEditorNodeToAstNode(node) {
+  const font = node.characterFont ?? "default";
+  const charNode = new CharNode(node.expr);
+  if (font === "default") {
+    return charNode;
+  }
+  return new CommandNode(CHAR_FONT_EXPORT_TEX[font], [], [new ChainNode([charNode])]);
+}
+function commandIdForTex(tex) {
+  for (const spec of Object.values(ATOMIC_COMMANDS)) {
+    const renderTex = spec.arabicRenderTex;
+    if (spec.englishTex === tex || spec.arabicTex === tex || renderTex === tex) {
+      return spec.id;
+    }
+  }
+  return null;
+}
+function operatorCommandIdForTex(tex) {
+  for (const spec of Object.values(ATOMIC_OPERATOR_COMMANDS)) {
+    if (spec.Tex === tex) {
+      return spec.id;
+    }
+  }
+  return null;
+}
+function cloneChainWithFreshIds(chain) {
+  return structuredClone(chain);
+}
+function attachScripts(astNode, editorNode) {
+  if (astNode.superscript) {
+    const sup = chainToEditorChain(astNode.superscript);
+    if (!sup.editable) {
+      return sup;
+    }
+    editorNode.superscript = sup.chain;
+  }
+  if (astNode.subscript) {
+    const sub = chainToEditorChain(astNode.subscript);
+    if (!sub.editable) {
+      return sub;
+    }
+    editorNode.subscript = sub.chain;
+  }
+  return null;
+}
+var MATRIX_ENV_NAMES = /* @__PURE__ */ new Set(["matrix", "pmatrix", "bmatrix", "Bmatrix", "vmatrix", "Vmatrix"]);
+function isGridEnvName(value) {
+  return MATRIX_ENV_NAMES.has(value) || value === "array" || value === "aligned";
+}
+function isMatrixEnvName(value) {
+  return MATRIX_ENV_NAMES.has(value);
+}
+function parseEnvOpening(opening) {
+  const match = /^\\begin\{([^}]+)\}(?:\{([lcr]+)\})?$/.exec(opening);
+  if (!match) {
+    return null;
+  }
+  const envName = match[1] ?? "";
+  if (!isGridEnvName(envName)) {
+    return null;
+  }
+  if (envName === "array") {
+    const spec = match[2] ?? "c";
+    return {
+      envName,
+      alignments: spec.split("").map((alignment) => alignment)
+    };
+  }
+  return { envName };
+}
+function splitEnvLine(line) {
+  const cells = [];
+  let current = [];
+  for (const node of line.chain) {
+    if (node instanceof OperatorNode && node.expr === "&") {
+      cells.push(new ChainNode(current));
+      current = [];
+    } else {
+      current.push(node);
+    }
+  }
+  cells.push(new ChainNode(current));
+  return cells;
+}
+function envToEditorNode(node) {
+  const parsed = parseEnvOpening(node.opening);
+  if (!parsed) {
+    return { editable: false, reason: `\u0628\u064A\u0626\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645\u0629 \u062D\u0627\u0644\u064A\u0627: ${node.opening}` };
+  }
+  const expectedClosing = `\\end{${parsed.envName}}`;
+  if (node.closing !== expectedClosing) {
+    return { editable: false, reason: `\u0625\u063A\u0644\u0627\u0642 \u0628\u064A\u0626\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645 \u062D\u0627\u0644\u064A\u0627: ${node.closing}` };
+  }
+  const rowCells = node.lines.map(splitEnvLine);
+  const rows = Math.max(1, rowCells.length);
+  const columns = Math.max(1, ...rowCells.map((row) => row.length));
+  const env = createGridEnvNode(parsed.envName, rows, columns, parsed.alignments);
+  for (let rowIndex = 0; rowIndex < rows; rowIndex += 1) {
+    const row = rowCells[rowIndex] ?? [];
+    for (let columnIndex = 0; columnIndex < columns; columnIndex += 1) {
+      const cell = chainToEditorChain(row[columnIndex] ?? new ChainNode());
+      if (!cell.editable) {
+        return cell;
+      }
+      env.matrixRows[rowIndex][columnIndex] = cell.chain;
+    }
+  }
+  if (parsed.envName === "array") {
+    env.columnAlignments = Array.from(
+      { length: columns },
+      (_, index) => parsed.alignments?.[index] ?? "c"
+    );
+  }
+  if (isMatrixEnvName(parsed.envName)) {
+    env.matrixStyle = parsed.envName;
+  }
+  const scripts = attachScripts(node, env);
+  return scripts ?? { editable: true, node: env };
+}
+function charFromTextLikeCommand(node) {
+  const commandFont = COMMAND_FONT_MAP[node.name];
+  if (commandFont === void 0) {
+    return null;
+  }
+  if (node.optionalArgs.length > 0 || node.mandatoryArgs.length !== 1) {
+    return null;
+  }
+  const arg = node.mandatoryArgs[0];
+  if (arg.chain.length !== 1) {
+    return null;
+  }
+  const child = arg.chain[0];
+  if (child instanceof CommandNode) {
+    const nested = charFromTextLikeCommand(child);
+    if (!nested?.editable) {
+      return null;
+    }
+    if (commandFont !== "infer") {
+      nested.node.characterFont = commandFont;
+    }
+    const scripts2 = attachScripts(node, nested.node);
+    return scripts2 ?? nested;
+  }
+  if (!(child instanceof CharNode)) {
+    return null;
+  }
+  const normalized = normalizeCharImportExpr(child.expr);
+  const characterFont = commandFont === "infer" ? normalized.characterFont : commandFont;
+  const editorNode = createEditorNode("char", normalized.expr);
+  if (characterFont !== "default") {
+    editorNode.characterFont = characterFont;
+  }
+  const scripts = attachScripts(node, editorNode);
+  return scripts ?? { editable: true, node: editorNode };
+}
+function commandToEditorNode(node) {
+  if (node.name === "\\frac" && node.mandatoryArgs.length >= 2) {
+    const frac = createFracNode();
+    const numerator = chainToEditorChain(node.mandatoryArgs[0]);
+    const denominator = chainToEditorChain(node.mandatoryArgs[1]);
+    if (!numerator.editable) {
+      return numerator;
+    }
+    if (!denominator.editable) {
+      return denominator;
+    }
+    frac.numerator = numerator.chain;
+    frac.denominator = denominator.chain;
+    const scripts = attachScripts(node, frac);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: frac };
+  }
+  if ((node.name === "\\sqrt" || node.name === "\\arabsqrt" || node.name === "\\arsqrt") && node.mandatoryArgs.length >= 1) {
+    const sqrt = createSqrtNode();
+    const radicand = chainToEditorChain(node.mandatoryArgs[0]);
+    if (!radicand.editable) {
+      return radicand;
+    }
+    sqrt.radicand = radicand.chain;
+    if (node.optionalArgs[0]) {
+      const rootIndex = chainToEditorChain(node.optionalArgs[0]);
+      if (!rootIndex.editable) {
+        return rootIndex;
+      }
+      sqrt.rootIndex = rootIndex.chain;
+    }
+    const scripts = attachScripts(node, sqrt);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: sqrt };
+  }
+  if (node.name === "\\overset" && node.mandatoryArgs.length >= 2) {
+    const overset = createOversetNode();
+    const overExpr = chainToEditorChain(node.mandatoryArgs[0]);
+    const baseExpr = chainToEditorChain(node.mandatoryArgs[1]);
+    if (!overExpr.editable) {
+      return overExpr;
+    }
+    if (!baseExpr.editable) {
+      return baseExpr;
+    }
+    overset.overExpr = overExpr.chain;
+    overset.baseExpr = baseExpr.chain;
+    const scripts = attachScripts(node, overset);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: overset };
+  }
+  if (node.name === "\\underset" && node.mandatoryArgs.length >= 2) {
+    const underset = createUndersetNode();
+    const underExpr = chainToEditorChain(node.mandatoryArgs[0]);
+    const baseExpr = chainToEditorChain(node.mandatoryArgs[1]);
+    if (!underExpr.editable) {
+      return underExpr;
+    }
+    if (!baseExpr.editable) {
+      return baseExpr;
+    }
+    underset.underExpr = underExpr.chain;
+    underset.baseExpr = baseExpr.chain;
+    const scripts = attachScripts(node, underset);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: underset };
+  }
+  const accentId = accentCommandIdFromTex(node.name);
+  if (accentId && node.mandatoryArgs.length >= 1) {
+    const accent = createAccentNode(accentId);
+    const baseExpr = chainToEditorChain(node.mandatoryArgs[0]);
+    if (!baseExpr.editable) {
+      return baseExpr;
+    }
+    accent.baseExpr = baseExpr.chain;
+    const scripts = attachScripts(node, accent);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: accent };
+  }
+  const atomicId = commandIdForTex(node.name);
+  if (atomicId && node.optionalArgs.length === 0 && node.mandatoryArgs.length === 0) {
+    const atomic = createEditorNode("atomicCommand", atomicId);
+    const scripts = attachScripts(node, atomic);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: atomic };
+  }
+  const operatorId = operatorCommandIdForTex(node.name);
+  if (operatorId && node.optionalArgs.length === 0 && node.mandatoryArgs.length === 0) {
+    const atomicOperator = createEditorNode("atomicOperatorCommand", operatorId);
+    const scripts = attachScripts(node, atomicOperator);
+    if (scripts) {
+      return scripts;
+    }
+    return { editable: true, node: atomicOperator };
+  }
+  const textLike = charFromTextLikeCommand(node);
+  if (textLike) {
+    return textLike;
+  }
+  return { editable: false, reason: `\u0623\u0645\u0631 \u0631\u064A\u0627\u0636\u064A \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645 \u062D\u0627\u0644\u064A\u0627: ${node.name}` };
+}
+function astNodeToEditorNode(node) {
+  if (node instanceof CharNode) {
+    const normalized = normalizeCharImportExpr(node.expr);
+    const editorNode = createEditorNode("char", normalized.expr);
+    if (normalized.characterFont !== "default") {
+      editorNode.characterFont = normalized.characterFont;
+    }
+    const scripts = attachScripts(node, editorNode);
+    return scripts ?? { editable: true, node: editorNode };
+  }
+  if (node instanceof NumberNode) {
+    const editorNode = createEditorNode("number", node.expr);
+    const scripts = attachScripts(node, editorNode);
+    return scripts ?? { editable: true, node: editorNode };
+  }
+  if (node instanceof OperatorNode) {
+    return { editable: true, node: createEditorNode("operator", node.expr) };
+  }
+  if (node instanceof DelimiterNode) {
+    const editorNode = createDelimiterNode(node.leftDelimExpr, node.rightDelimExpr);
+    const inner = chainToEditorChain(node.innerExpr);
+    if (!inner.editable) {
+      return inner;
+    }
+    editorNode.innerExpr = inner.chain;
+    const scripts = attachScripts(node, editorNode);
+    return scripts ?? { editable: true, node: editorNode };
+  }
+  if (node instanceof CommandNode) {
+    return commandToEditorNode(node);
+  }
+  if (node instanceof EnvNode) {
+    return envToEditorNode(node);
+  }
+  return { editable: false, reason: `\u0639\u0642\u062F\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645\u0629 \u062D\u0627\u0644\u064A\u0627: ${node.nodeType}` };
+}
+function chainToEditorChain(chain) {
+  const nodes = [];
+  for (const astNode of chain.chain) {
+    const converted = astNodeToEditorNode(astNode);
+    if (!converted.editable) {
+      return converted;
+    }
+    nodes.push(converted.node);
+  }
+  return { editable: true, chain: createEditorChain(nodes) };
+}
+function mathObjectToEditorSession(math) {
+  if (math.lines.length !== 1) {
+    return { editable: false, reason: "\u062A\u062D\u0631\u064A\u0631 \u0627\u0644\u0645\u0639\u0627\u062F\u0644\u0627\u062A \u0645\u062A\u0639\u062F\u062F\u0629 \u0627\u0644\u0623\u0633\u0637\u0631 \u062F\u0627\u062E\u0644 \u0627\u0644\u0645\u0633\u062A\u0646\u062F \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645 \u0628\u0639\u062F" };
+  }
+  const english = chainToEditorChain(math.lines[0]);
+  if (!english.editable) {
+    return english;
+  }
+  const arabic = cloneChainWithFreshIds(english.chain);
+  const session = createEditorSession(english.chain, arabic, "english");
+  session.sync = buildInitialSyncMap(session.englishTree, session.arabicTree);
+  return { editable: true, session: cloneEditorSession(session) };
+}
+function attachAstScripts(editorNode, astNode) {
+  if (editorNode.superscript) {
+    const sup = editorChainToAstChain(editorNode.superscript);
+    if (!sup.ok) {
+      return sup;
+    }
+    astNode.superscript = sup.chain;
+  }
+  if (editorNode.subscript) {
+    const sub = editorChainToAstChain(editorNode.subscript);
+    if (!sub.ok) {
+      return sub;
+    }
+    astNode.subscript = sub.chain;
+  }
+  return null;
+}
+function editorEnvOpening(node) {
+  const envName = node.envName ?? node.matrixStyle;
+  if (!envName) {
+    return null;
+  }
+  if (envName === "array") {
+    const spec = (node.columnAlignments ?? []).slice(0, node.matrixRows?.[0]?.length ?? 0).join("") || "c";
+    return { opening: `\\begin{array}{${spec}}`, closing: "\\end{array}" };
+  }
+  return { opening: `\\begin{${envName}}`, closing: `\\end{${envName}}` };
+}
+function editorEnvToAstNode(node) {
+  const wrapper = editorEnvOpening(node);
+  if (!wrapper || !node.matrixRows) {
+    return { ok: false, reason: "\u0628\u064A\u0626\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645\u0629 \u062D\u0627\u0644\u064A\u0627" };
+  }
+  const lines = [];
+  for (const row of node.matrixRows) {
+    const lineNodes = [];
+    for (let columnIndex = 0; columnIndex < row.length; columnIndex += 1) {
+      if (columnIndex > 0) {
+        lineNodes.push(new OperatorNode("&"));
+      }
+      const cell = editorChainToAstChain(row[columnIndex]);
+      if (!cell.ok) {
+        return cell;
+      }
+      lineNodes.push(...cell.chain.chain);
+    }
+    lines.push(new ChainNode(lineNodes));
+  }
+  const env = new EnvNode(wrapper.opening, lines, wrapper.closing);
+  const scripts = attachAstScripts(node, env);
+  return scripts ?? { ok: true, node: env };
+}
+function accentChainForExport(accent) {
+  if (!accent) {
+    return { ok: true, chain: new ChainNode([]) };
+  }
+  return editorChainToAstChain(accent);
+}
+function nodeFromAccentBase(command, accent, base) {
+  if (accent.chain.length > 0) {
+    return new CommandNode(command, [], [accent, base]);
+  }
+  if (base.chain.length === 1) {
+    return base.chain[0];
+  }
+  return new DelimiterNode("", base, "");
+}
+function editorNodeToAstNode(node) {
+  let astNode;
+  if (node.kind === "char") {
+    astNode = charEditorNodeToAstNode(node);
+  } else if (node.kind === "number") {
+    astNode = new NumberNode(node.expr);
+  } else if (node.kind === "operator") {
+    astNode = new OperatorNode(node.expr);
+  } else if (node.kind === "delimiter" && node.innerExpr) {
+    const inner = editorChainToAstChain(node.innerExpr);
+    if (!inner.ok) {
+      return inner;
+    }
+    astNode = new DelimiterNode(node.leftDelimExpr, inner.chain, node.rightDelimExpr);
+  } else if (node.kind === "frac" && node.numerator && node.denominator) {
+    const numerator = editorChainToAstChain(node.numerator);
+    const denominator = editorChainToAstChain(node.denominator);
+    if (!numerator.ok) {
+      return numerator;
+    }
+    if (!denominator.ok) {
+      return denominator;
+    }
+    astNode = new CommandNode("\\frac", [], [numerator.chain, denominator.chain]);
+  } else if (node.kind === "sqrt" && node.radicand) {
+    const radicand = editorChainToAstChain(node.radicand);
+    if (!radicand.ok) {
+      return radicand;
+    }
+    const optionalArgs = [];
+    if (node.rootIndex && node.rootIndex.nodes.length > 0) {
+      const rootIndex = editorChainToAstChain(node.rootIndex);
+      if (!rootIndex.ok) {
+        return rootIndex;
+      }
+      optionalArgs.push(rootIndex.chain);
+    }
+    astNode = new CommandNode("\\sqrt", optionalArgs, [radicand.chain]);
+  } else if (node.kind === "overset" && node.baseExpr) {
+    const accent = accentChainForExport(node.overExpr);
+    if (!accent.ok) {
+      return accent;
+    }
+    const baseExpr = editorChainToAstChain(node.baseExpr);
+    if (!baseExpr.ok) {
+      return baseExpr;
+    }
+    astNode = nodeFromAccentBase("\\overset", accent.chain, baseExpr.chain);
+  } else if (node.kind === "underset" && node.baseExpr) {
+    const accent = accentChainForExport(node.underExpr);
+    if (!accent.ok) {
+      return accent;
+    }
+    const baseExpr = editorChainToAstChain(node.baseExpr);
+    if (!baseExpr.ok) {
+      return baseExpr;
+    }
+    astNode = nodeFromAccentBase("\\underset", accent.chain, baseExpr.chain);
+  } else if (node.kind === "accent" && node.baseExpr) {
+    const tex = accentCommandSpec(node.expr)?.englishTex;
+    if (!tex) {
+      return { ok: false, reason: `\u0644\u0643\u0646\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645\u0629 \u062D\u0627\u0644\u064A\u0627: ${node.expr}` };
+    }
+    const baseExpr = editorChainToAstChain(node.baseExpr);
+    if (!baseExpr.ok) {
+      return baseExpr;
+    }
+    astNode = new CommandNode(tex, [], [baseExpr.chain]);
+  } else if (node.kind === "atomicCommand") {
+    const tex = atomicCommandSpec(node.expr)?.englishTex;
+    if (!tex) {
+      return { ok: false, reason: `\u0623\u0645\u0631 \u0631\u064A\u0627\u0636\u064A \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645 \u062D\u0627\u0644\u064A\u0627: ${node.expr}` };
+    }
+    astNode = new CommandNode(tex);
+  } else if (node.kind === "atomicOperatorCommand") {
+    const tex = atomicOperatorCommandSpec(node.expr)?.Tex;
+    if (!tex) {
+      return { ok: false, reason: `\u0631\u0645\u0632 \u0631\u064A\u0627\u0636\u064A \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645 \u062D\u0627\u0644\u064A\u0627: ${node.expr}` };
+    }
+    astNode = new CommandNode(tex);
+  } else if (node.kind === "env") {
+    return editorEnvToAstNode(node);
+  } else {
+    return { ok: false, reason: `\u0639\u0642\u062F\u0629 \u0631\u064A\u0627\u0636\u064A\u0629 \u063A\u064A\u0631 \u0645\u062F\u0639\u0648\u0645\u0629 \u062D\u0627\u0644\u064A\u0627: ${node.kind}` };
+  }
+  const scripts = attachAstScripts(node, astNode);
+  return scripts ?? { ok: true, node: astNode };
+}
+function editorChainToAstChain(chain) {
+  const nodes = [];
+  for (const editorNode of chain.nodes) {
+    const converted = editorNodeToAstNode(editorNode);
+    if (!converted.ok) {
+      return converted;
+    }
+    nodes.push(converted.node);
+  }
+  return { ok: true, chain: new ChainNode(nodes) };
+}
+function mathNodeFromEditorSession(session, mathMode = "$", closing = "$") {
+  const converted = editorChainToAstChain(session.englishTree);
+  if (!converted.ok) {
+    return converted;
+  }
+  return {
+    ok: true,
+    math: {
+      nodeType: "MathObject",
+      mathMode,
+      lines: [converted.chain],
+      closing
+    }
+  };
+}
+
+// src/debugJson.ts
+function lineColumnForPosition(text, position) {
+  const before = text.slice(0, Math.max(0, position));
+  const lines = before.split("\n");
+  return {
+    line: lines.length,
+    column: (lines[lines.length - 1]?.length ?? 0) + 1
+  };
+}
+function parseJsonDebugInput(text) {
+  try {
+    return { ok: true, value: JSON.parse(text) };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const positionMatch = message.match(/position\s+(\d+)/i);
+    if (positionMatch) {
+      const position = Number(positionMatch[1]);
+      if (Number.isFinite(position)) {
+        const location = lineColumnForPosition(text, position);
+        return { ok: false, error: `Invalid JSON at line ${String(location.line)}, column ${String(location.column)}: ${message}` };
+      }
+    }
+    return { ok: false, error: `Invalid JSON: ${message}` };
+  }
+}
+
 // src/react/ButexEditor.tsx
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 var DIGIT_FORM_OPTIONS = [
@@ -7532,6 +8719,7 @@ ${latex || messages.empty}`;
 var ButexEditor = forwardRef(
   function ButexEditor2({ className, debug = false, defaultSide, uiLocale = "ar", initialSession, onSessionChange }, ref) {
     const messages = equationEditorMessages(uiLocale);
+    const debugEnabled = debug || typeof window !== "undefined" && new URLSearchParams(window.location.search).get("debug") === "1";
     const wrapperRef = useRef(null);
     const surfaceRef = useRef(null);
     const inputRef = useRef(null);
@@ -7549,7 +8737,7 @@ var ButexEditor = forwardRef(
     const digitFormBtnRef = useRef(null);
     const runtimeRef = useRef(null);
     const debugRef = useRef(debug);
-    debugRef.current = debug;
+    debugRef.current = debugEnabled;
     const uiLocaleRef = useRef(uiLocale);
     uiLocaleRef.current = uiLocale;
     const onSessionChangeRef = useRef(onSessionChange);
@@ -7557,6 +8745,9 @@ var ButexEditor = forwardRef(
     const debugBodyHiddenRef = useRef(false);
     const [debugBodyHidden, setDebugBodyHidden] = useState(false);
     debugBodyHiddenRef.current = debugBodyHidden;
+    const [debugImportOpen, setDebugImportOpen] = useState(false);
+    const [debugImportText, setDebugImportText] = useState("");
+    const [debugImportError, setDebugImportError] = useState("");
     const [digitMenuOpen, setDigitMenuOpen] = useState(false);
     const [characterFontMenuOpen, setCharacterFontMenuOpen] = useState(false);
     const [delimiterMenuOpen, setDelimiterMenuOpen] = useState(false);
@@ -7637,6 +8828,54 @@ ${arabic || currentMessages.empty}`;
     }, []);
     const updatePreviewRef = useRef(updatePreview);
     updatePreviewRef.current = updatePreview;
+    async function copyDebugText(text) {
+      try {
+        await navigator.clipboard.writeText(text);
+      } catch {
+      }
+    }
+    function currentMathObjectJsonText() {
+      const session = runtimeRef.current?.getSession();
+      if (!session) {
+        return "";
+      }
+      const math = mathNodeFromEditorSession(session);
+      if (!math.ok) {
+        return "";
+      }
+      return JSON.stringify(toMathObjectJson(math.math), null, 2);
+    }
+    function openDebugMathObjectImport() {
+      setDebugImportText(currentMathObjectJsonText());
+      setDebugImportError("");
+      setDebugImportOpen(true);
+    }
+    function applyDebugMathObjectImport() {
+      const parsed = parseJsonDebugInput(debugImportText);
+      if (!parsed.ok) {
+        setDebugImportError(parsed.error);
+        return;
+      }
+      try {
+        const math = fromMathObjectJson(parsed.value, activeEditorSide);
+        const result = mathObjectToEditorSession(math);
+        if (!result.editable) {
+          setDebugImportError(result.reason);
+          return;
+        }
+        const next = { ...result.session, activeSide: activeEditorSide };
+        runtimeRef.current?.setSession(next);
+        setSelectedDigitForm(next.currentDigitForm ?? "western");
+        setSelectedCharacterFont(next.currentCharacterFont ?? "default");
+        setActiveEditorSide(next.activeSide);
+        onSessionChangeRef.current?.(next);
+        setDebugImportError("");
+        setDebugImportOpen(false);
+        void updatePreviewRef.current(next);
+      } catch (importError) {
+        setDebugImportError(importError instanceof Error ? importError.message : String(importError));
+      }
+    }
     useEffect(() => {
       injectWidgetChromeCss();
       injectBuTeXEditorStyles(typeof document !== "undefined" ? document : void 0);
@@ -8797,7 +10036,7 @@ ${arabic || currentMessages.empty}`;
             /* @__PURE__ */ jsx("div", { ref: renderErrorRef, className: "error", hidden: true })
           ] }),
           /* @__PURE__ */ jsx("section", { className: "panel panel-preview", "aria-label": messages.renderPreview, children: /* @__PURE__ */ jsx("div", { ref: mathOutputRef, className: "preview-box" }) }),
-          debug ? /* @__PURE__ */ jsxs("section", { className: "panel", children: [
+          debugEnabled ? /* @__PURE__ */ jsxs("section", { className: "panel", children: [
             /* @__PURE__ */ jsxs("div", { className: "dev-strip", children: [
               /* @__PURE__ */ jsx("span", { className: "dev-badge", children: messages.development }),
               /* @__PURE__ */ jsx("div", { ref: latexLinesRef, className: "ascii" }),
@@ -8805,6 +10044,8 @@ ${arabic || currentMessages.empty}`;
             ] }),
             /* @__PURE__ */ jsxs("div", { style: { marginTop: 12 }, children: [
               /* @__PURE__ */ jsxs("div", { className: "debug-head", children: [
+                /* @__PURE__ */ jsx("button", { type: "button", onClick: () => void copyDebugText(currentMathObjectJsonText()), children: "Copy MathObject JSON" }),
+                /* @__PURE__ */ jsx("button", { type: "button", "aria-expanded": debugImportOpen, onClick: openDebugMathObjectImport, children: "Import MathObject JSON" }),
                 /* @__PURE__ */ jsx(
                   "button",
                   {
@@ -8840,6 +10081,35 @@ ${arabic || currentMessages.empty}`;
                   }
                 )
               ] }),
+              debugImportOpen ? /* @__PURE__ */ jsxs("div", { className: "debug-json-import", children: [
+                /* @__PURE__ */ jsx(
+                  "textarea",
+                  {
+                    value: debugImportText,
+                    "aria-label": "Import MathObject JSON",
+                    spellCheck: false,
+                    onChange: (event) => {
+                      setDebugImportText(event.currentTarget.value);
+                      setDebugImportError("");
+                    }
+                  }
+                ),
+                /* @__PURE__ */ jsxs("div", { className: "debug-head", children: [
+                  /* @__PURE__ */ jsx("button", { type: "button", onClick: applyDebugMathObjectImport, children: "Apply" }),
+                  /* @__PURE__ */ jsx(
+                    "button",
+                    {
+                      type: "button",
+                      onClick: () => {
+                        setDebugImportOpen(false);
+                        setDebugImportError("");
+                      },
+                      children: "Cancel"
+                    }
+                  )
+                ] }),
+                debugImportError ? /* @__PURE__ */ jsx("p", { className: "debug-json-error", children: debugImportError }) : null
+              ] }) : null,
               /* @__PURE__ */ jsx("div", { ref: debugLogRef, className: "debug-log" })
             ] })
           ] }) : null