@drghaliasri/butex 3.2.2

package/dist/document.js

@@ -0,0 +1,2886 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/document/index.ts
+var document_exports = {};
+__export(document_exports, {
+  addDocumentBlock: () => addDocumentBlock,
+  addListItem: () => addListItem,
+  addNestedListBlock: () => addNestedListBlock,
+  addTableColumn: () => addTableColumn,
+  addTableRow: () => addTableRow,
+  buildDocumentPreview: () => buildDocumentPreview,
+  buildInlines: () => buildInlines,
+  createDocumentBlock: () => createDocumentBlock,
+  createEmptyDocument: () => createEmptyDocument,
+  createImageBlock: () => createImageBlock,
+  createListBlock: () => createListBlock,
+  createRawBlock: () => createRawBlock,
+  createTableBlock: () => createTableBlock,
+  createTextBlock: () => createTextBlock,
+  detectMathSpans: () => detectMathSpans,
+  documentInlineText: () => documentInlineText,
+  fromDocumentJson: () => fromDocumentJson,
+  fromMathObjectJson: () => fromMathObjectJson,
+  insertMathSpanFromEditor: () => insertMathSpanFromEditor,
+  isDisplayMathNode: () => isDisplayMathNode,
+  isSupportedDocumentCommand: () => isSupportedDocumentCommand,
+  mathNodeFromEditorSession: () => mathNodeFromEditorSession,
+  mathSourceFromEditorSession: () => mathSourceFromEditorSession,
+  moveDocumentBlock: () => moveDocumentBlock,
+  removeDocumentBlock: () => removeDocumentBlock,
+  removeListItem: () => removeListItem,
+  removeTableColumn: () => removeTableColumn,
+  removeTableRow: () => removeTableRow,
+  renderDocumentLatex: () => renderDocumentLatex,
+  renderMathNodeLatex: () => renderMathNodeLatex,
+  replaceMathSpanFromEditor: () => replaceMathSpanFromEditor,
+  replaceMathSpanSource: () => replaceMathSpanSource,
+  updateImageBlock: () => updateImageBlock,
+  updateListItemValue: () => updateListItemValue,
+  updateRawBlockValue: () => updateRawBlockValue,
+  updateTableCell: () => updateTableCell,
+  updateTableColumns: () => updateTableColumns,
+  updateTextBlockValue: () => updateTextBlockValue
+});
+module.exports = __toCommonJS(document_exports);
+
+// 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" ? "\\arabsqrt" : 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 renderMathNodeLatex(math) {
+  const lines = math.lines.map((line) => line.arabicLatex());
+  if (math.mathMode === "$" || math.mathMode === "\\(") {
+    return math.mathMode + lines.join(" ") + math.closing;
+  }
+  if (math.mathMode === "$$" || math.mathMode === "\\[") {
+    if (lines.length === 1) {
+      return math.mathMode + "\n" + lines[0] + "\n" + math.closing;
+    }
+    return math.mathMode + "\n" + lines.map((line) => `    ${line}`).join(" \\\\\n") + "\n" + math.closing;
+  }
+  if (lines.length === 1) {
+    return `${math.mathMode}
+    ${lines[0]}
+${math.closing}`;
+  }
+  return `${math.mathMode}
+${lines.map((line) => `    ${line}`).join(" \\\\\n")}
+${math.closing}`;
+}
+function isDisplayMathNode(math) {
+  return math.mathMode === "$$" || math.mathMode === "\\[" || math.mathMode.startsWith("\\begin{");
+}
+
+// src/document/mathSpans.ts
+var MATH_ENVIRONMENTS = /* @__PURE__ */ new Set([
+  "equation",
+  "equation*",
+  "align",
+  "align*",
+  "aligned",
+  "gather",
+  "gather*",
+  "multline",
+  "multline*"
+]);
+function isEscaped(value, index) {
+  let slashCount = 0;
+  let i = index - 1;
+  while (i >= 0 && value[i] === "\\") {
+    slashCount += 1;
+    i -= 1;
+  }
+  return slashCount % 2 === 1;
+}
+function findClosingDollar(value, start) {
+  let i = start;
+  while (i < value.length) {
+    if (value[i] === "$" && !isEscaped(value, i)) {
+      return i;
+    }
+    i += 1;
+  }
+  return -1;
+}
+function findClosingToken(value, token, start) {
+  const index = value.indexOf(token, start);
+  return index < 0 ? -1 : index;
+}
+function environmentSpan(value, start) {
+  const match = /^\\begin\{([A-Za-z*]+)\}/.exec(value.slice(start));
+  if (!match) {
+    return null;
+  }
+  const envName = match[1] ?? "";
+  if (!MATH_ENVIRONMENTS.has(envName)) {
+    return null;
+  }
+  const opening = match[0] ?? "";
+  const closing = `\\end{${envName}}`;
+  const closingStart = value.indexOf(closing, start + opening.length);
+  if (closingStart < 0) {
+    return null;
+  }
+  const end = closingStart + closing.length;
+  return {
+    start,
+    end,
+    source: value.slice(start, end),
+    mathMode: opening,
+    closing
+  };
+}
+function detectMathSpans(value) {
+  const spans = [];
+  let i = 0;
+  while (i < value.length) {
+    if (value.startsWith("\\begin{", i)) {
+      const span = environmentSpan(value, i);
+      if (span) {
+        spans.push(span);
+        i = span.end;
+        continue;
+      }
+    }
+    if (value.startsWith("\\(", i)) {
+      const close = findClosingToken(value, "\\)", i + 2);
+      if (close >= 0) {
+        const end = close + 2;
+        spans.push({ start: i, end, source: value.slice(i, end), mathMode: "\\(", closing: "\\)" });
+        i = end;
+        continue;
+      }
+    }
+    if (value.startsWith("\\[", i)) {
+      const close = findClosingToken(value, "\\]", i + 2);
+      if (close >= 0) {
+        const end = close + 2;
+        spans.push({ start: i, end, source: value.slice(i, end), mathMode: "\\[", closing: "\\]" });
+        i = end;
+        continue;
+      }
+    }
+    if (value.startsWith("$$", i) && !isEscaped(value, i)) {
+      const close = value.indexOf("$$", i + 2);
+      if (close >= 0) {
+        const end = close + 2;
+        spans.push({ start: i, end, source: value.slice(i, end), mathMode: "$$", closing: "$$" });
+        i = end;
+        continue;
+      }
+    }
+    if (value[i] === "$" && !isEscaped(value, i)) {
+      const close = findClosingDollar(value, i + 1);
+      if (close >= 0) {
+        const end = close + 1;
+        spans.push({ start: i, end, source: value.slice(i, end), mathMode: "$", closing: "$" });
+        i = end;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return spans;
+}
+function buildInlines(value, mathObjects = [], mode = "english") {
+  const spans = detectMathSpans(value);
+  if (mathObjects.length > 0 && mathObjects.length !== spans.length) {
+    throw new Error(`math_objects count mismatch: detected ${String(spans.length)}, got ${String(mathObjects.length)}`);
+  }
+  const inlines = [];
+  let index = 0;
+  spans.forEach((span, spanIndex) => {
+    if (span.start > index) {
+      inlines.push({ kind: "text", text: value.slice(index, span.start) });
+    }
+    const mathJson = mathObjects[spanIndex];
+    if (mathJson) {
+      if (mathJson.math_mode !== span.mathMode || mathJson.closing !== span.closing) {
+        throw new Error("math_objects order mismatch");
+      }
+      inlines.push({ kind: "math", source: span.source, math: fromMathObjectJson(mathJson, mode) });
+    } else {
+      inlines.push({ kind: "math", source: span.source, math: null });
+    }
+    index = span.end;
+  });
+  if (index < value.length) {
+    inlines.push({ kind: "text", text: value.slice(index) });
+  }
+  if (inlines.length === 0) {
+    inlines.push({ kind: "text", text: value });
+  }
+  return inlines;
+}
+
+// src/document/fromJson.ts
+var TEXT_COMMANDS = /* @__PURE__ */ new Set(["\\section", "\\subsection", "\\subsubsection", "\\paragraph"]);
+var LIST_COMMANDS = /* @__PURE__ */ new Set(["\\begin{itemize}", "\\begin{enumerate}"]);
+function isObject2(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRecordOfStrings(value) {
+  if (!isObject2(value)) {
+    return false;
+  }
+  return Object.values(value).every((entry) => typeof entry === "string");
+}
+function requireString(value, message) {
+  if (typeof value !== "string") {
+    throw new Error(message);
+  }
+  return value;
+}
+function asBlockJson(value) {
+  if (!isObject2(value)) {
+    throw new Error("Document block must be an object");
+  }
+  if (typeof value.command !== "string") {
+    throw new Error("Document block requires string command");
+  }
+  return value;
+}
+function parseTextBlock(json, mode) {
+  const value = requireString(json.value, `${json.command} requires string value`);
+  return {
+    kind: "textBlock",
+    command: json.command,
+    value,
+    inlines: buildInlines(value, json.math_objects ?? [], mode)
+  };
+}
+function closingForList(command) {
+  return command === "\\begin{itemize}" ? "\\end{itemize}" : "\\end{enumerate}";
+}
+function parseListItem(json, mode) {
+  const value = requireString(json.value, "Document list item requires string value");
+  const blocksJson = Array.isArray(json.blocks) ? json.blocks : [];
+  return {
+    value,
+    inlines: buildInlines(value, json.math_objects ?? [], mode),
+    blocks: blocksJson.map((block) => parseBlock(asBlockJson(block), mode))
+  };
+}
+function parseListBlock(json, mode) {
+  if (!Array.isArray(json.items)) {
+    throw new Error(`${json.command} requires items array`);
+  }
+  const command = json.command;
+  const expectedClosing = closingForList(command);
+  const closing = json.closing === void 0 ? expectedClosing : requireString(json.closing, `${json.command} requires string closing`);
+  if (closing !== expectedClosing) {
+    throw new Error(`${json.command} closing must be ${expectedClosing}`);
+  }
+  return {
+    kind: "list",
+    command,
+    closing,
+    items: json.items.map((item) => parseListItem(item, mode))
+  };
+}
+function parseTableBlock(json, mode) {
+  if (!Array.isArray(json.rows)) {
+    throw new Error("\\begin{tabular} requires rows array");
+  }
+  const mathObjects = json.math_objects ?? [];
+  let mathObjectIndex = 0;
+  const rows = json.rows.map((row) => {
+    if (!Array.isArray(row)) {
+      throw new Error("\\begin{tabular} rows must be arrays");
+    }
+    return row.map((cell) => {
+      const value = requireString(cell, "\\begin{tabular} cells must be strings");
+      const spanCount = detectMathSpans(value).length;
+      const cellMathObjects = mathObjects.slice(mathObjectIndex, mathObjectIndex + spanCount);
+      mathObjectIndex += spanCount;
+      return buildInlines(value, cellMathObjects, mode);
+    });
+  });
+  if (mathObjects.length > 0 && mathObjects.length !== mathObjectIndex) {
+    throw new Error(`math_objects count mismatch: detected ${String(mathObjectIndex)}, got ${String(mathObjects.length)}`);
+  }
+  return {
+    kind: "table",
+    command: "\\begin{tabular}",
+    closing: "\\end{tabular}",
+    columns: typeof json.columns === "string" ? json.columns : "",
+    rows
+  };
+}
+function parseImageBlock(json) {
+  return {
+    kind: "image",
+    command: "\\includegraphics",
+    value: requireString(json.value, "\\includegraphics requires string value"),
+    options: isRecordOfStrings(json.options) ? json.options : {}
+  };
+}
+function parseRawBlock(json) {
+  return {
+    kind: "raw",
+    command: "\\raw",
+    value: typeof json.value === "string" ? json.value : ""
+  };
+}
+function parseBlock(json, mode) {
+  if (TEXT_COMMANDS.has(json.command)) {
+    return parseTextBlock(json, mode);
+  }
+  if (LIST_COMMANDS.has(json.command)) {
+    return parseListBlock(json, mode);
+  }
+  if (json.command === "\\begin{tabular}") {
+    return parseTableBlock(json, mode);
+  }
+  if (json.command === "\\includegraphics") {
+    return parseImageBlock(json);
+  }
+  if (json.command === "\\raw") {
+    return parseRawBlock(json);
+  }
+  return {
+    kind: "raw",
+    command: "\\raw",
+    value: typeof json.value === "string" ? json.value : json.command
+  };
+}
+function fromDocumentJson(json, mode = "english") {
+  if (!isObject2(json) || json.node_type !== "DocumentObject") {
+    throw new Error('DocumentObject requires node_type "DocumentObject"');
+  }
+  if (!Array.isArray(json.blocks)) {
+    throw new Error("DocumentObject requires blocks array");
+  }
+  return {
+    nodeType: "DocumentObject",
+    blocks: json.blocks.map((block) => parseBlock(asBlockJson(block), mode))
+  };
+}
+function createEmptyDocument() {
+  return {
+    nodeType: "DocumentObject",
+    blocks: []
+  };
+}
+function createTextBlock(command, value = "") {
+  return {
+    kind: "textBlock",
+    command,
+    value,
+    inlines: buildInlines(value)
+  };
+}
+function createRawBlock(value = "") {
+  return {
+    kind: "raw",
+    command: "\\raw",
+    value
+  };
+}
+function createListBlock(command, items = []) {
+  return {
+    kind: "list",
+    command,
+    closing: closingForList(command),
+    items: items.map((value) => ({ value, inlines: buildInlines(value), blocks: [] }))
+  };
+}
+function createTableBlock(rows = [], columns = "") {
+  return {
+    kind: "table",
+    command: "\\begin{tabular}",
+    closing: "\\end{tabular}",
+    columns,
+    rows: rows.map((row) => row.map((cell) => buildInlines(cell)))
+  };
+}
+function createImageBlock(value = "", options = {}) {
+  return {
+    kind: "image",
+    command: "\\includegraphics",
+    value,
+    options
+  };
+}
+function isSupportedDocumentCommand(command) {
+  return TEXT_COMMANDS.has(command) || LIST_COMMANDS.has(command) || command === "\\begin{tabular}" || command === "\\includegraphics" || command === "\\raw";
+}
+
+// src/editor/atomicCommands.ts
+var ATOMIC_COMMANDS = {
+  ///////////////////////// Functions ////////////////////////////////
+  //////////////// Trigonometric Functions 
+  cos: {
+    id: "cos",
+    category: "function",
+    englishTex: "\\cos",
+    arabicTex: "\\arcos",
+    arabicLabel: "\u062C\u062A\u0627",
+    title: "\u062C\u064A\u0628 \u0627\u0644\u062A\u0645\u0627\u0645"
+  },
+  sin: {
+    id: "sin",
+    category: "function",
+    englishTex: "\\sin",
+    arabicTex: "\\arsin",
+    arabicLabel: "\u062C\u0627",
+    title: "\u062C\u064A\u0628"
+  },
+  tan: {
+    id: "tan",
+    category: "function",
+    englishTex: "\\tan",
+    arabicTex: "\\artan",
+    arabicLabel: "\u0638\u0627",
+    title: "\u0638\u0644"
+  },
+  cot: {
+    id: "cot",
+    category: "function",
+    englishTex: "\\cot",
+    arabicTex: "\\arcot",
+    arabicLabel: "\u0638\u062A\u0627",
+    title: "\u0638\u0644 \u062A\u0645\u0627\u0645"
+  },
+  sec: {
+    id: "sec",
+    category: "function",
+    englishTex: "\\sec",
+    arabicTex: "\\arsec",
+    arabicLabel: "\u0642\u0627",
+    title: "\u0642\u0627\u0637\u0639"
+  },
+  csc: {
+    id: "csc",
+    category: "function",
+    englishTex: "\\csc",
+    arabicTex: "\\arcsc",
+    arabicLabel: "\u0642\u062A\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u062A\u0645\u0627\u0645"
+  },
+  /////////////////// Arc Trigonometric Functions 
+  arccos: {
+    id: "arccos",
+    category: "function",
+    englishTex: "\\arccos",
+    arabicTex: "\\aracos",
+    arabicLabel: "\u0642\u062C\u062A\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u062C\u064A\u0628 \u0627\u0644\u062A\u0645\u0627\u0645"
+  },
+  arcsin: {
+    id: "arcsin",
+    category: "function",
+    englishTex: "\\arcsin",
+    arabicTex: "\\arasin",
+    arabicLabel: "\u0642\u062C\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u062C\u064A\u0628"
+  },
+  arctan: {
+    id: "arctan",
+    category: "function",
+    englishTex: "\\arctan",
+    arabicTex: "\\aratan",
+    arabicLabel: "\u0642\u0638\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u0638\u0644"
+  },
+  arccot: {
+    id: "arccot",
+    category: "function",
+    englishTex: "\\arccot",
+    arabicTex: "\\aracot",
+    arabicLabel: "\u0642\u0638\u062A\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u0638\u0644 \u0627\u0644\u062A\u0645\u0627\u0645"
+  },
+  arcsec: {
+    id: "arcsec",
+    category: "function",
+    englishTex: "\\arcsec",
+    arabicTex: "\\arasec",
+    arabicLabel: "\u0642\u0642\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u0627\u0644\u0642\u0627\u0637\u0639"
+  },
+  arccsc: {
+    id: "arccsc",
+    category: "function",
+    englishTex: "\\arccsc",
+    arabicTex: "\\aracsc",
+    arabicLabel: "\u0642\u0642\u062A\u0627",
+    title: "\u0642\u0627\u0637\u0639 \u0627\u0644\u0642\u0627\u0637\u0639 \u0627\u0644\u062A\u0645\u0627\u0645"
+  },
+  ///////////////// Hyperbolic Functions 
+  cosh: {
+    id: "cosh",
+    category: "function",
+    englishTex: "\\cosh",
+    arabicTex: "\\arcosh",
+    arabicLabel: "\u062C\u062A\u0632\u0627",
+    title: "\u062C\u064A\u0628 \u0627\u0644\u062A\u0645\u0627\u0645 \u0627\u0644\u0632\u0627\u0626\u062F"
+  },
+  sinh: {
+    id: "sinh",
+    category: "function",
+    englishTex: "\\sinh",
+    arabicTex: "\\arsinh",
+    arabicLabel: "\u062C\u0632\u0627",
+    title: "\u062C\u064A\u0628 \u0627\u0644\u0632\u0627\u0626\u062F"
+  },
+  tanh: {
+    id: "tanh",
+    category: "function",
+    englishTex: "\\tanh",
+    arabicTex: "\\artanh",
+    arabicLabel: "\u0638\u0632\u0627",
+    title: "\u0638\u0644 \u0627\u0644\u0632\u0627\u0626\u062F"
+  },
+  coth: {
+    id: "coth",
+    category: "function",
+    englishTex: "\\coth",
+    arabicTex: "\\arcoth",
+    arabicLabel: "\u0638\u062A\u0632\u0627",
+    title: "\u0638\u0644 \u062A\u0645\u0627\u0645 \u0627\u0644\u0632\u0627\u0626\u062F"
+  },
+  ////// These function somehow doesnt exist in LaTeX and therefore MathJax, skip for now. no problem.
+  // sech: {
+  //   id: 'sech',
+  //   category: 'function',
+  //   englishTex: '\\sech',
+  //   arabicTex: '\\arsech',
+  //   arabicLabel: 'قزا',
+  //   title: 'قاطع الزائد',
+  // },
+  // csch: {
+  //   id: 'csch',
+  //   category: 'function',
+  //   englishTex: '\\csch',
+  //   arabicTex: '\\arcsch',
+  //   arabicLabel: 'قتزا',
+  //   title: 'قاطع تمام الزائد',
+  // },
+  ///////////////// arc Hyperbolic Functions 
+  ///// Not on MathJax, skip for now, it is okay.
+  ////////////////////// Limits & Series ////////////////////////////////
+  sum: {
+    id: "sum",
+    category: "limits_series",
+    englishTex: "\\sum",
+    arabicTex: "\\arsum",
+    arabicLabel: "\u0645\u062C\u0640\u0640\u0640",
+    title: "\u0645\u062C\u0645\u0648\u0639"
+  },
+  prod: {
+    id: "prod",
+    category: "limits_series",
+    englishTex: "\\prod",
+    arabicTex: "\\arprod",
+    arabicLabel: "\u062C\u0640\u0640\u0640\u062F",
+    title: "\u062C\u062F\u0627\u0621"
+  },
+  lim: {
+    id: "lim",
+    category: "limits_series",
+    englishTex: "\\lim",
+    arabicTex: "\\arlim",
+    arabicLabel: "\u0646\u0640\u0640\u0640\u0640\u0640\u0647\u0627",
+    title: "\u062D\u062F"
+  },
+  max: {
+    id: "max",
+    category: "limits_series",
+    englishTex: "\\max",
+    arabicTex: "\\armax",
+    arabicLabel: "\u0623\u0643\u0628\u0631",
+    title: "\u0623\u0643\u0628\u0631"
+  },
+  min: {
+    id: "min",
+    category: "limits_series",
+    englishTex: "\\min",
+    arabicTex: "\\armin",
+    arabicLabel: "\u0623\u0635\u063A\u0631",
+    title: "\u0623\u0635\u063A\u0631"
+  },
+  sup: {
+    id: "sup",
+    category: "limits_series",
+    englishTex: "\\sup",
+    arabicTex: "\\arsup",
+    arabicLabel: "\u0623\u0639\u0644\u0649",
+    title: "\u0623\u0639\u0644\u0649"
+  },
+  inf: {
+    id: "inf",
+    category: "limits_series",
+    englishTex: "\\inf",
+    arabicTex: "\\arinf",
+    arabicLabel: "\u0623\u062F\u0646\u0649",
+    title: "\u0623\u062F\u0646\u0649"
+  },
+  ////////////////////// Logarithmic and Exponential and Determinant Functions ////////////////////////////////
+  pi: {
+    id: "pi",
+    category: "function2",
+    englishTex: "\\pi",
+    arabicTex: "\\arpi",
+    arabicLabel: "\u0637",
+    title: "\u0646\u0633\u0628\u0629 \u0627\u0644\u062F\u0627\u0626\u0631\u0629"
+  },
+  exp: {
+    id: "exp",
+    category: "function2",
+    englishTex: "\\exp",
+    arabicTex: "\\arexp",
+    arabicLabel: "\u0647\u0640",
+    title: "\u0623\u0633\u064A\u0629"
+  },
+  ln: {
+    id: "ln",
+    category: "function2",
+    englishTex: "\\ln",
+    arabicTex: "\\arln",
+    arabicRenderTex: "\\prescript{}{\\arexp}{\\arlog}",
+    arabicLabel: "\u0644\u0648",
+    title: "\u0644\u0648\u063A\u0627\u0631\u064A\u062A\u0645 \u0637\u0628\u064A\u0639\u064A"
+  },
+  log: {
+    id: "log",
+    category: "function2",
+    englishTex: "\\log",
+    arabicTex: "\\arlog",
+    arabicLabel: "\u0644\u0648",
+    title: "\u0644\u0648\u063A\u0627\u0631\u064A\u062A\u0645"
+  },
+  det: {
+    id: "det",
+    category: "function2",
+    englishTex: "\\det",
+    arabicTex: "\\ardet",
+    arabicLabel: "\u0645\u062D\u062F\u062F",
+    title: "\u0645\u062D\u062F\u062F"
+  },
+  ////////////////////// Groups /////////////////////////////////
+  N: {
+    id: "N",
+    category: "groups",
+    englishTex: "\\mathbb{N}",
+    arabicTex: "\\arabN",
+    arabicLabel: "\u0637",
+    title: "\u0623\u0639\u062F\u0627\u062F \u0637\u0628\u064A\u0639\u064A\u0629"
+  },
+  Z: {
+    id: "Z",
+    category: "groups",
+    englishTex: "\\mathbb{Z}",
+    arabicTex: "\\arabZ",
+    arabicLabel: "\u0635",
+    title: "\u0623\u0639\u062F\u0627\u062F \u0635\u062D\u064A\u062D\u0629"
+  },
+  Q: {
+    id: "Q",
+    category: "groups",
+    englishTex: "\\mathbb{Q}",
+    arabicTex: "\\arabQ",
+    arabicLabel: "\u0646",
+    title: "\u0623\u0639\u062F\u0627\u062F \u0646\u0633\u0628\u064A\u0629"
+  },
+  R: {
+    id: "R",
+    category: "groups",
+    englishTex: "\\mathbb{R}",
+    arabicTex: "\\arabR",
+    arabicLabel: "\u062D",
+    title: "\u0623\u0639\u062F\u0627\u062F \u062D\u0642\u064A\u0642\u064A\u0629"
+  },
+  C: {
+    id: "C",
+    category: "groups",
+    englishTex: "\\mathbb{C}",
+    arabicTex: "\\arabC",
+    arabicLabel: "\u0639",
+    title: "\u0623\u0639\u062F\u0627\u062F \u0639\u064F\u0642\u062F\u064A\u0629"
+  },
+  H: {
+    id: "H",
+    category: "groups",
+    englishTex: "\\mathbb{H}",
+    arabicTex: "\\arabH",
+    arabicLabel: "\u0631",
+    title: "\u0623\u0639\u062F\u0627\u062F \u0631\u0628\u0627\u0639\u064A\u0629"
+  },
+  ////////////////////// Operations ////////////////////////////
+  ////////////////////// Spacing ////////////////////////////////
+  negThinSpace: {
+    id: "negThinSpace",
+    category: "spacing",
+    englishTex: "\\!",
+    arabicTex: "\\!",
+    arabicLabel: "",
+    title: "\u0641\u0631\u0627\u063A \u0633\u0627\u0644\u0628 \u0631\u0641\u064A\u0639",
+    spacing: { direction: "negative", level: 1 }
+  },
+  mediumSpace: {
+    id: "mediumSpace",
+    category: "spacing",
+    englishTex: "\\:",
+    arabicTex: "\\:",
+    arabicLabel: "",
+    title: "\u0641\u0631\u0627\u063A \u0645\u062A\u0648\u0633\u0637",
+    spacing: { direction: "positive", level: 1 }
+  },
+  thickSpace: {
+    id: "thickSpace",
+    category: "spacing",
+    englishTex: "\\;",
+    arabicTex: "\\;",
+    arabicLabel: "",
+    title: "\u0641\u0631\u0627\u063A \u0639\u0631\u064A\u0636",
+    spacing: { direction: "positive", level: 2 }
+  },
+  quadSpace: {
+    id: "quadSpace",
+    category: "spacing",
+    englishTex: "\\quad",
+    arabicTex: "\\quad",
+    arabicLabel: "",
+    title: "\u0641\u0631\u0627\u063A \u0643\u0628\u064A\u0631",
+    spacing: { direction: "positive", level: 3 }
+  },
+  qquadSpace: {
+    id: "qquadSpace",
+    category: "spacing",
+    englishTex: "\\qquad",
+    arabicTex: "\\qquad",
+    arabicLabel: "",
+    title: "\u0641\u0631\u0627\u063A \u0643\u0628\u064A\u0631 \u062C\u062F\u0627",
+    spacing: { direction: "positive", level: 4 }
+  }
+};
+function atomicCommandSpec(id) {
+  return Object.prototype.hasOwnProperty.call(ATOMIC_COMMANDS, id) ? ATOMIC_COMMANDS[id] : null;
+}
+
+// src/editor/atomicCommandsOperators.ts
+var ATOMIC_OPERATOR_COMMANDS = {
+  inf: {
+    id: "inf",
+    category: "operators1",
+    Tex: "\\infty",
+    mirror: true,
+    Label: "\u221E",
+    title: "\u0627\u0644\u0644\u0627\u0646\u0647\u0627\u064A\u0629",
+    svg_path: null
+  },
+  times: {
+    id: "times",
+    category: "operators1",
+    Tex: "\\times",
+    mirror: false,
+    Label: "\xD7",
+    title: "\u0636\u0631\u0628",
+    svg_path: null
+  },
+  div: {
+    id: "div",
+    category: "operators1",
+    Tex: "\\div",
+    mirror: false,
+    Label: "\xF7",
+    title: "\u0642\u0633\u0645\u0629",
+    svg_path: null
+  },
+  pm: {
+    id: "pm",
+    category: "operators1",
+    Tex: "\\pm",
+    mirror: false,
+    Label: "\xB1",
+    title: "\u0632\u0627\u0626\u062F \u0623\u0648 \u0646\u0627\u0642\u0635",
+    svg_path: null
+  },
+  mp: {
+    id: "mp",
+    category: "operators1",
+    Tex: "\\mp",
+    mirror: false,
+    Label: "\u2213",
+    title: "\u0646\u0627\u0642\u0635 \u0623\u0648 \u0632\u0627\u0626\u062F",
+    svg_path: null
+  },
+  neq: {
+    id: "neq",
+    category: "operators1",
+    Tex: "\\neq",
+    mirror: false,
+    Label: "\u2260",
+    title: "\u0644\u0627 \u064A\u0633\u0627\u0648\u064A",
+    svg_path: null
+  },
+  approx: {
+    id: "approx",
+    category: "operators1",
+    Tex: "\\approx",
+    mirror: false,
+    Label: "\u2248",
+    title: "\u062A\u0642\u0631\u064A\u0628\u0627 \u064A\u0633\u0627\u0648\u064A",
+    svg_path: null
+  },
+  sim: {
+    id: "sim",
+    category: "operators1",
+    Tex: "\\sim",
+    mirror: false,
+    Label: "\u223C",
+    title: "\u0645\u0634\u0627\u0628\u0647",
+    svg_path: null
+  },
+  mid: {
+    id: "mid",
+    category: "operators1",
+    Tex: "\\mid",
+    mirror: false,
+    Label: "\u2223",
+    title: "\u064A\u0642\u0633\u0645",
+    svg_path: null
+  },
+  leq: {
+    id: "leq",
+    category: "operators1",
+    Tex: "\\leq",
+    mirror: true,
+    Label: "\u2264",
+    title: "\u0623\u0635\u063A\u0631 \u0645\u0646 \u0623\u0648 \u064A\u0633\u0627\u0648\u064A",
+    svg_path: null
+  },
+  geq: {
+    id: "geq",
+    category: "operators1",
+    Tex: "\\geq",
+    mirror: true,
+    Label: "\u2265",
+    title: "\u0623\u0643\u0628\u0631 \u0645\u0646 \u0623\u0648 \u064A\u0633\u0627\u0648\u064A",
+    svg_path: null
+  },
+  ///// Operators 2
+  propto: {
+    id: "propto",
+    category: "operators2",
+    Tex: "\\propto",
+    mirror: true,
+    Label: "\u221D",
+    title: "\u064A\u062A\u0646\u0627\u0633\u0628 \u0645\u0639",
+    svg_path: null
+  },
+  in: {
+    id: "in",
+    category: "operators2",
+    Tex: "\\in",
+    mirror: true,
+    Label: "\u2208",
+    title: "\u064A\u0646\u062A\u0645\u064A \u0625\u0644\u0649",
+    svg_path: null
+  },
+  notin: {
+    id: "notin",
+    category: "operators2",
+    Tex: "\\notin",
+    mirror: false,
+    Label: "\u2209",
+    title: "\u0644\u0627 \u064A\u0646\u062A\u0645\u064A \u0625\u0644\u0649",
+    svg_path: null
+  },
+  subset: {
+    id: "subset",
+    category: "operators2",
+    Tex: "\\subset",
+    mirror: true,
+    Label: "\u2282",
+    title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u062C\u0632\u0626\u064A\u0629 \u0645\u0646",
+    svg_path: null
+  },
+  supset: {
+    id: "supset",
+    category: "operators2",
+    Tex: "\\supset",
+    mirror: true,
+    Label: "\u2283",
+    title: "\u0645\u062C\u0645\u0648\u0639\u0629 \u0634\u0627\u0645\u0644\u0629 \u0644\u0640",
+    svg_path: null
+  },
+  subseteq: {
+    id: "subseteq",
+    category: "operators2",
+    Tex: "\\subseteq",
+    mirror: 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
+  },
+  supseteq: {
+    id: "supseteq",
+    category: "operators2",
+    Tex: "\\supseteq",
+    mirror: 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
+  },
+  cap: {
+    id: "cap",
+    category: "operators2",
+    Tex: "\\cap",
+    mirror: false,
+    Label: "\u2229",
+    title: "\u062A\u0642\u0627\u0637\u0639",
+    svg_path: null
+  },
+  cup: {
+    id: "cup",
+    category: "operators2",
+    Tex: "\\cup",
+    mirror: false,
+    Label: "\u222A",
+    title: "\u0627\u062A\u062D\u0627\u062F",
+    svg_path: null
+  },
+  emptyset: {
+    id: "emptyset",
+    category: "operators2",
+    Tex: "\\emptyset",
+    mirror: false,
+    Label: "\u2205",
+    title: "\u0627\u0644\u0645\u062C\u0645\u0648\u0639\u0629 \u0627\u0644\u062E\u0627\u0644\u064A\u0629",
+    svg_path: null
+  },
+  nsubseteq: {
+    id: "nsubseteq",
+    category: "operators2",
+    Tex: "\\nsubseteq",
+    mirror: 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
+  },
+  nsupseteq: {
+    id: "nsupseteq",
+    category: "operators2",
+    Tex: "\\nsupseteq",
+    mirror: 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
+  },
+  ///// Dots
+  ldots: {
+    id: "ldots",
+    category: "dots",
+    Tex: "\\ldots",
+    mirror: false,
+    Label: "\u2026",
+    title: "\u0646\u0642\u0627\u0637 \u0623\u0641\u0642\u064A\u0629",
+    svg_path: null
+  },
+  cdot: {
+    id: "cdot",
+    category: "dots",
+    Tex: "\\cdot",
+    mirror: false,
+    Label: "\xB7",
+    title: "\u0646\u0642\u0637\u0629 \u0636\u0631\u0628",
+    svg_path: null
+  },
+  cdots: {
+    id: "cdots",
+    category: "dots",
+    Tex: "\\cdots",
+    mirror: false,
+    Label: "\u22EF",
+    title: "\u0646\u0642\u0627\u0637 \u0648\u0633\u0637\u064A\u0629 \u0623\u0641\u0642\u064A\u0629",
+    svg_path: null
+  },
+  vdots: {
+    id: "vdots",
+    category: "dots",
+    Tex: "\\vdots",
+    mirror: false,
+    Label: "\u22EE",
+    title: "\u0646\u0642\u0627\u0637 \u0639\u0645\u0648\u062F\u064A\u0629",
+    svg_path: null
+  },
+  ddots: {
+    id: "ddots",
+    category: "dots",
+    Tex: "\\ddots",
+    mirror: true,
+    displayMirror: false,
+    Label: "\u22F1",
+    title: "\u0646\u0642\u0627\u0637 \u0642\u0637\u0631\u064A\u0629",
+    svg_path: null
+  },
+  /// Operators 3
+  leftrightarrowDouble: {
+    id: "leftrightarrowDouble",
+    category: "operators3",
+    Tex: "\\Leftrightarrow",
+    mirror: false,
+    Label: "\u21D4",
+    title: "\u064A\u0643\u0627\u0641\u0626",
+    svg_path: null
+  },
+  rightleftharpoons: {
+    id: "rightleftharpoons",
+    category: "operators3",
+    Tex: "\\rightleftharpoons",
+    mirror: true,
+    Label: "\u21CC",
+    title: "\u0627\u062A\u0632\u0627\u0646",
+    svg_path: null
+  },
+  leftarrow: {
+    id: "leftarrow",
+    category: "operators3",
+    Tex: "\\leftarrow",
+    mirror: true,
+    Label: "\u2190",
+    title: "\u0633\u0647\u0645 \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
+    svg_path: null
+  },
+  rightarrow: {
+    id: "rightarrow",
+    category: "operators3",
+    Tex: "\\rightarrow",
+    mirror: true,
+    Label: "\u2192",
+    title: "\u0633\u0647\u0645 \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
+    svg_path: null
+  },
+  leftarrowDouble: {
+    id: "leftarrowDouble",
+    category: "operators3",
+    Tex: "\\Leftarrow",
+    mirror: true,
+    Label: "\u21D0",
+    title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0625\u0644\u0649 \u0627\u0644\u064A\u0633\u0627\u0631",
+    svg_path: null
+  },
+  rightarrowDouble: {
+    id: "rightarrowDouble",
+    category: "operators3",
+    Tex: "\\Rightarrow",
+    mirror: true,
+    Label: "\u21D2",
+    title: "\u0633\u0647\u0645 \u0645\u0632\u062F\u0648\u062C \u0625\u0644\u0649 \u0627\u0644\u064A\u0645\u064A\u0646",
+    svg_path: null
+  },
+  leftharpoonup: {
+    id: "leftharpoonup",
+    category: "operators3",
+    Tex: "\\leftharpoonup",
+    mirror: 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
+  },
+  rightharpoonup: {
+    id: "rightharpoonup",
+    category: "operators3",
+    Tex: "\\rightharpoonup",
+    mirror: 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
+  },
+  leftharpoondown: {
+    id: "leftharpoondown",
+    category: "operators3",
+    Tex: "\\leftharpoondown",
+    mirror: 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
+  },
+  rightharpoondown: {
+    id: "rightharpoondown",
+    category: "operators3",
+    Tex: "\\rightharpoondown",
+    mirror: 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
+  },
+  // Integrals
+  int: {
+    id: "int",
+    category: "integrals",
+    Tex: "\\int",
+    mirror: true,
+    Label: "\u222B",
+    title: "\u062A\u0643\u0627\u0645\u0644",
+    svg_path: null
+  },
+  iint: {
+    id: "iint",
+    category: "integrals",
+    Tex: "\\iint",
+    mirror: true,
+    Label: "\u222C",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u0645\u0632\u062F\u0648\u062C",
+    svg_path: null
+  },
+  iiint: {
+    id: "iiint",
+    category: "integrals",
+    Tex: "\\iiint",
+    mirror: true,
+    Label: "\u222D",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u062B\u0644\u0627\u062B\u064A",
+    svg_path: null
+  },
+  iiiint: {
+    id: "iiiint",
+    category: "integrals",
+    Tex: "\\iiiint",
+    mirror: true,
+    Label: "\u2A0C",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u0631\u0628\u0627\u0639\u064A",
+    svg_path: null
+  },
+  oint: {
+    id: "oint",
+    category: "integrals",
+    Tex: "\\oint",
+    mirror: true,
+    Label: "\u222E",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u0645\u063A\u0644\u0642",
+    svg_path: null
+  },
+  oiint: {
+    id: "oiint",
+    category: "integrals",
+    Tex: "\\oiint",
+    mirror: true,
+    Label: "\u222F",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u0633\u0637\u062D\u064A \u0645\u063A\u0644\u0642",
+    svg_path: null
+  },
+  oiiint: {
+    id: "oiiint",
+    category: "integrals",
+    Tex: "\\oiiint",
+    mirror: true,
+    Label: "\u2230",
+    title: "\u062A\u0643\u0627\u0645\u0644 \u062D\u062C\u0645\u064A \u0645\u063A\u0644\u0642",
+    svg_path: null
+  }
+};
+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 atomicOperatorCommandSpec(id) {
+  return Object.prototype.hasOwnProperty.call(ATOMIC_OPERATOR_COMMANDS, id) ? ATOMIC_OPERATOR_COMMANDS[id] : null;
+}
+
+// src/editor/digits.ts
+var WESTERN = "0123456789";
+var ARABIC_INDIC = "\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669";
+var PERSIAN_INDIC = "\u06F0\u06F1\u06F2\u06F3\u06F4\u06F5\u06F6\u06F7\u06F8\u06F9";
+var digitSets = {
+  western: WESTERN,
+  arabicIndic: ARABIC_INDIC,
+  persianIndic: PERSIAN_INDIC
+};
+function digitValue(char) {
+  const western = WESTERN.indexOf(char);
+  if (western >= 0) {
+    return western;
+  }
+  const arabicIndic = ARABIC_INDIC.indexOf(char);
+  if (arabicIndic >= 0) {
+    return arabicIndic;
+  }
+  return PERSIAN_INDIC.indexOf(char);
+}
+function formatDigits(value, digitForm = "western") {
+  const target = digitSets[digitForm];
+  return Array.from(value, (char) => {
+    const value2 = digitValue(char);
+    return value2 >= 0 ? target[value2] : char;
+  }).join("");
+}
+
+// src/editor/render.ts
+function selectedDigitForm(options) {
+  return options?.digitForm ?? "western";
+}
+function optionalRootIndexArabic(node, options) {
+  if (!node.rootIndex) {
+    return "";
+  }
+  const rendered = renderChainArabic(node.rootIndex, options);
+  return rendered === "" ? "" : `[${rendered}]`;
+}
+function arabicScripts(node, content, options) {
+  const sup = node.superscript ? renderChainArabic(node.superscript, options) : "";
+  const sub = node.subscript ? renderChainArabic(node.subscript, options) : "";
+  if (sup !== "" || sub !== "") {
+    return `\\prescript{${sup}}{${sub}}{${content}}`;
+  }
+  return content;
+}
+function reverseAlignmentForArabic(alignment) {
+  if (alignment === "l") {
+    return "r";
+  }
+  if (alignment === "r") {
+    return "l";
+  }
+  return "c";
+}
+function renderMatrixRowsArabic(node, options) {
+  if (!node.matrixRows) {
+    return "";
+  }
+  const envName = node.envName ?? node.matrixStyle;
+  if (!envName) {
+    return "";
+  }
+  const rows = node.matrixRows.map(
+    (row) => row.slice().reverse().map((cell) => renderChainArabic(cell, options)).join(" & ")
+  );
+  if (envName === "array") {
+    const spec = (node.columnAlignments ?? []).slice(0, node.matrixRows[0]?.length ?? 0).reverse().map(reverseAlignmentForArabic).join("");
+    return `\\begin{array}{${spec || "c"}}${rows.join(" \\\\\n")}\\end{array}`;
+  }
+  return `\\begin{${envName}}${rows.join(" \\\\\n")}\\end{${envName}}`;
+}
+function escapeText(s) {
+  return s.replace(/\\/g, "\\textbackslash{}").replace(/[{}]/g, "\\$&");
+}
+function renderCharContent(node, options) {
+  const expr = formatDigits(node.expr, selectedDigitForm(options));
+  const font = node.characterFont ?? "default";
+  if (font === "takween") {
+    return `\\butextakween{${escapeText(expr)}}`;
+  }
+  if (font === "diwani") {
+    return `\\butexdiwani{${escapeText(expr)}}`;
+  }
+  if (font === "diwaniOutline") {
+    return `\\butexdiwanioutline{${escapeText(expr)}}`;
+  }
+  return expr;
+}
+function renderNodeArabic(node, options) {
+  if (node.kind === "delimiter" && node.innerExpr) {
+    const content = `${node.leftDelimExpr}${renderChainArabic(node.innerExpr, options)}${node.rightDelimExpr}`;
+    return arabicScripts(node, content, options);
+  }
+  if (node.kind === "frac" && node.numerator && node.denominator) {
+    const content = `\\frac{${renderChainArabic(node.numerator, options)}}{${renderChainArabic(node.denominator, options)}}`;
+    return arabicScripts(node, content, options);
+  }
+  if (node.kind === "sqrt" && node.radicand) {
+    const content = `\\arabsqrt${optionalRootIndexArabic(node, options)}{${renderChainArabic(node.radicand, options)}}`;
+    return arabicScripts(node, content, options);
+  }
+  if (node.kind === "env") {
+    return arabicScripts(node, renderMatrixRowsArabic(node, options), options);
+  }
+  if (node.kind === "atomicCommand") {
+    const spec = atomicCommandSpec(node.expr);
+    const content = spec?.arabicRenderTex ?? spec?.arabicTex ?? node.expr;
+    return arabicScripts(node, content, options);
+  }
+  if (node.kind === "atomicOperatorCommand") {
+    const spec = atomicOperatorCommandSpec(node.expr);
+    const tex = spec?.Tex ?? node.expr;
+    const content = spec?.mirror ? `\\butexmirror{${tex}}` : tex;
+    return arabicScripts(node, content, options);
+  }
+  if (node.kind === "char") {
+    const expr = formatDigits(node.expr, selectedDigitForm(options));
+    const content = renderCharContent(node, options);
+    return arabicScripts(node, (node.characterFont ?? "default") === "default" ? `\\text{${escapeText(expr)}}` : content, options);
+  }
+  return arabicScripts(node, formatDigits(node.expr, selectedDigitForm(options)), options);
+}
+function renderChainArabic(chain, options) {
+  return chain.nodes.slice().reverse().map((node) => renderNodeArabic(node, options)).join(" ");
+}
+function renderArabicLatexFromSession(session) {
+  return renderChainArabic(session.arabicTree, { digitForm: session.currentDigitForm ?? "western" });
+}
+
+// src/editor/display/delimiter.ts
+var DELIMITER_CSS = `
+.delim-pair {
+  display: inline-flex;
+  align-items: stretch;
+  min-height: 1.85em;
+}
+
+.delim-inner {
+  display: inline-flex;
+  align-items: center;
+}
+
+.delim {
+  display: inline-flex;
+  align-self: stretch;
+  align-items: center;
+  justify-content: center;
+  color: var(--butex-delim-color, #475569);
+  padding: 0 1px;
+  min-height: 100%;
+}
+
+.delim-glyph {
+  display: inline-flex;
+  align-items: center;
+  line-height: 1;
+  font-size: clamp(20px, 1.08em + 0.8vh, 36px);
+  transform: translateY(-20%) scaleY(var(--butex-delim-scale, 1));
+  transform-origin: center;
+}
+`.trim();
+
+// src/editor/display/frac.ts
+var FRAC_CSS = `
+.frac {
+  display: inline-flex;
+  flex-direction: column;
+  align-items: stretch;
+  justify-content: center;
+  vertical-align: middle;
+  margin: 0 3px;
+  min-width: 1.5em;
+}
+
+.frac-num,
+.frac-den {
+  display: inline-flex;
+  justify-content: center;
+  align-items: center;
+  min-height: 1.1em;
+  padding: 0 4px;
+}
+
+.frac-bar {
+  align-self: stretch;
+  height: 1px;
+  background: var(--butex-frac-bar, currentColor);
+  opacity: 0.88;
+}
+`.trim();
+
+// src/editor/display/sqrt.ts
+var SQRT_CSS = `
+.sqrt {
+  display: inline-flex;
+  align-items: stretch;
+  position: relative;
+  vertical-align: middle;
+  margin: 0 2px;
+  min-height: 2.1em;
+  direction: ltr;
+  --butex-sqrt-scale: 1;
+}
+
+.sqrt.sqrt--english .sqrt-root {
+  order: 1;
+}
+
+.sqrt.sqrt--english .sqrt-sign {
+  order: 2;
+}
+
+.sqrt.sqrt--english .sqrt-radicand {
+  order: 3;
+}
+
+.sqrt.sqrt--arabic .sqrt-radicand {
+  order: 1;
+}
+
+.sqrt.sqrt--arabic .sqrt-sign {
+  order: 2;
+}
+
+.sqrt.sqrt--arabic .sqrt-root {
+  order: 3;
+}
+
+.sqrt.sqrt--arabic .sqrt-root,
+.sqrt.sqrt--arabic .sqrt-radicand {
+  direction: rtl;
+}
+
+.sqrt-root {
+  align-self: flex-start;
+  min-width: 0.9em;
+  min-height: 1em;
+  margin-inline-end: -0.18em;
+  transform: translate(0.16em, 0.02em);
+  font-size: 0.64em;
+  line-height: 1;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  position: relative;
+  z-index: 1;
+}
+
+.sqrt.sqrt--arabic .sqrt-root {
+  margin-inline-start: -0.22em;
+  margin-inline-end: 0;
+  transform: translate(-0.16em, 0.02em);
+}
+
+.sqrt-root .chain {
+  min-height: auto;
+}
+
+.sqrt-sign {
+  display: inline-flex;
+  align-items: flex-end;
+  justify-content: center;
+  align-self: stretch;
+  line-height: 0.78;
+  font-size: 2em;
+  color: var(--butex-sqrt-color, currentColor);
+  transform: scaleY(var(--butex-sqrt-scale));
+  transform-origin: center bottom;
+  margin-inline-end: -0.24em;
+  min-height: 100%;
+  position: relative;
+  z-index: 1;
+}
+
+.sqrt.sqrt--arabic .sqrt-sign {
+  transform: scaleX(-1) scaleY(var(--butex-sqrt-scale));
+  margin-inline-start: -0.24em;
+  margin-inline-end: 0;
+}
+
+.sqrt-radicand {
+  display: inline-flex;
+  align-items: center;
+  min-width: 1.35em;
+  min-height: 1.35em;
+  padding: 0.06em 0.24em 0;
+  border-top: 2px solid var(--butex-sqrt-bar, currentColor);
+  transform: translateY(-0.08em);
+  position: relative;
+}
+
+.sqrt-radicand .chain {
+  min-height: auto;
+}
+`.trim();
+
+// src/editor/display/env.ts
+var MATRIX_ENV_CSS = `
+.matrix-env {
+  display: inline-flex;
+  align-items: stretch;
+  vertical-align: middle;
+  margin: 0 3px;
+  --butex-matrix-delim-scale: 1.25;
+}
+
+.matrix-env__wrapper {
+  display: inline-flex;
+  align-self: stretch;
+  align-items: center;
+  justify-content: center;
+  min-width: 0.42em;
+  padding: 0 2px;
+  color: var(--butex-delim-color, currentColor);
+  font-family: ui-serif, "Cambria Math", "Times New Roman", serif;
+  font-size: clamp(22px, 1.35em + 0.8vh, 42px);
+  line-height: 1;
+  transform: scaleY(var(--butex-matrix-delim-scale));
+  transform-origin: center;
+}
+
+.matrix-env__grid {
+  display: inline-grid;
+  direction: ltr;
+  gap: 2px 5px;
+  align-items: center;
+  justify-items: center;
+  padding: 2px 3px;
+}
+
+.matrix-env__cell {
+  min-width: 1.35em;
+  min-height: 1.45em;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  border-radius: 5px;
+  border: 1px dashed rgba(148, 163, 184, 0.48);
+  padding: 1px 3px;
+}
+
+.matrix-env__cell .chain {
+  min-height: auto;
+}
+
+.matrix-env--arabic .matrix-env__cell {
+  direction: rtl;
+}
+
+.matrix-env--english .matrix-env__cell {
+  direction: ltr;
+}
+`.trim();
+
+// src/fonts/Diwani Letter Regular.ttf
+var Diwani_Letter_Regular_default = "data:font/ttf;base64,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";
+
+// src/fonts/DWNOUTSH.TTF
+var DWNOUTSH_default = "data:font/ttf;base64,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";
+
+// src/fonts/Takween.otf
+var Takween_default = "data:font/otf;base64,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";
+
+// src/diwani-font.ts
+var BUTEX_DIWANI_FONT_FAMILY = "Diwani Letter";
+var BUTEX_DIWANI_OUTLINE_FONT_FAMILY = "BuTeX Diwani Outline";
+var BUTEX_TAKWEEN_FONT_FAMILY = "BuTeX Takween";
+var BUTEX_DIWANI_FONT_STACK = `"${BUTEX_DIWANI_FONT_FAMILY}", Amiri, "Segoe UI", Tahoma, sans-serif`;
+var BUTEX_DIWANI_OUTLINE_FONT_STACK = `"${BUTEX_DIWANI_OUTLINE_FONT_FAMILY}", "${BUTEX_DIWANI_FONT_FAMILY}", Amiri, "Segoe UI", Tahoma, sans-serif`;
+var BUTEX_TAKWEEN_FONT_STACK = `"${BUTEX_TAKWEEN_FONT_FAMILY}", Amiri, "Segoe UI", Tahoma, sans-serif`;
+var BUTEX_DIWANI_FONT_FACE_CSS = `
+@font-face {
+  font-family: "${BUTEX_DIWANI_FONT_FAMILY}";
+  src: url("${Diwani_Letter_Regular_default}") format("truetype");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+`.trim();
+var BUTEX_TAKWEEN_FONT_FACE_CSS = `
+@font-face {
+  font-family: "${BUTEX_TAKWEEN_FONT_FAMILY}";
+  src: url("${Takween_default}") format("opentype");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+`.trim();
+var BUTEX_DIWANI_OUTLINE_FONT_FACE_CSS = `
+@font-face {
+  font-family: "${BUTEX_DIWANI_OUTLINE_FONT_FAMILY}";
+  src: url("${DWNOUTSH_default}") format("truetype");
+  font-weight: 400;
+  font-style: normal;
+  font-display: swap;
+}
+`.trim();
+var BUTEX_FONT_FACE_CSS = `
+${BUTEX_DIWANI_FONT_FACE_CSS}
+
+${BUTEX_DIWANI_OUTLINE_FONT_FACE_CSS}
+
+${BUTEX_TAKWEEN_FONT_FACE_CSS}
+`.trim();
+
+// src/editor/display/atomicCommand.ts
+var ATOMIC_COMMAND_CSS = `
+/* Shared atomic-command display */
+.atomic-command {
+  display: inline-flex;
+  align-items: center;
+  font-weight: 600;
+  line-height: 1;
+}
+
+/* Function-style commands: sin/cos/tan families. */
+.atomic-command--arabic {
+  font-family: ${BUTEX_DIWANI_FONT_STACK};
+  font-size: 1.15em;
+  direction: rtl;
+}
+
+.atomic-command--diwani-outline {
+  font-family: ${BUTEX_DIWANI_OUTLINE_FONT_STACK};
+}
+
+.atomic-command--english {
+  font-family: "Cambria Math", "Times New Roman", serif;
+  font-size: 0.96em;
+}
+
+.atomic-command-label-with-sub {
+  position: relative;
+  display: inline-block;
+  padding-inline-end: 0.45em;
+  padding-block-end: 0.22em;
+  line-height: 1;
+}
+
+.atomic-command-label-with-sub__sub {
+  position: absolute;
+  inset-inline-end: 0;
+  inset-block-end: 0;
+  font-size: 0.62em;
+  line-height: 1;
+}
+
+/* Spacing commands: tiny selectable marker, real spacing remains in LaTeX preview. */
+.atomic-spacing {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  width: 3px;
+  min-width: 3px;
+  height: 1em;
+  color: var(--butex-accent, currentColor);
+  opacity: 0.62;
+}
+
+.atomic-spacing__marker {
+  display: inline-block;
+  width: 3px;
+  height: 0.85em;
+  border-radius: 999px;
+  background: currentColor;
+}
+
+.atomic-spacing--negative {
+  color: var(--butex-danger, #dc2626);
+}
+`.trim();
+
+// src/editor/display/atomicCommandsOperators.ts
+var ATOMIC_OPERATOR_COMMAND_CSS = `
+.atomic-operator-command {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  min-width: 0.9em;
+  font-family: "Cambria Math", "Times New Roman", serif;
+  font-size: 1.05em;
+  font-weight: 600;
+  line-height: 1;
+}
+
+.atomic-operator-command--mirrored {
+  transform: scaleX(-1);
+}
+
+.atomic-operator-command__svg {
+  width: 1em;
+  height: 1em;
+  background: currentColor;
+}
+`.trim();
+
+// src/editor/styles.ts
+var BUTEX_EDITOR_CSS = `
+${BUTEX_FONT_FACE_CSS}
+
+.surface {
+  border: 1px solid var(--butex-border, #e2e8f0);
+  border-radius: 12px;
+  min-height: 100px;
+  padding: 8px 10px;
+  background: var(--butex-surface-bg, linear-gradient(180deg, #ffffff 0%, #fafbfc 100%));
+  color: var(--butex-surface-fg, #0f172a);
+  outline: none;
+  cursor: text;
+  transition: box-shadow 0.15s ease, border-color 0.15s ease;
+}
+
+.surface:focus {
+  border-color: var(--butex-focus-border, rgba(13, 148, 136, 0.45));
+  box-shadow: 0 0 0 3px var(--butex-focus-shadow, rgba(13, 148, 136, 0.12));
+}
+
+.surface.surface--arabic {
+  direction: rtl;
+}
+
+.surface.surface--english {
+  direction: ltr;
+}
+
+.node-value--takween {
+  font-family: ${BUTEX_TAKWEEN_FONT_STACK};
+}
+
+.node-value--diwani {
+  font-family: ${BUTEX_DIWANI_FONT_STACK};
+}
+
+.node-value--diwani-outline {
+  font-family: ${BUTEX_DIWANI_OUTLINE_FONT_STACK};
+}
+
+.chain {
+  display: inline-flex;
+  align-items: center;
+  gap: 0;
+  min-height: 28px;
+  flex-wrap: wrap;
+  row-gap: 2px;
+}
+
+.slot {
+  width: 5px;
+  min-height: 28px;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  cursor: pointer;
+  border-radius: 3px;
+}
+
+.slot:hover {
+  background: var(--butex-slot-hover, rgba(13, 148, 136, 0.08));
+}
+
+.slot.range-highlight {
+  background: var(--butex-selection-bg, rgba(13, 148, 136, 0.34));
+  width: 11px;
+  min-height: 42px;
+  border: 2px solid var(--butex-selection-border, rgba(15, 118, 110, 0.9));
+  position: relative;
+  z-index: 1;
+}
+
+.caret {
+  display: inline-block;
+  width: 2px;
+  height: 20px;
+  background: var(--butex-caret, #0f172a);
+  border-radius: 1px;
+  animation: butex-editor-blink 1s step-end infinite;
+}
+
+@keyframes butex-editor-blink {
+  50% { opacity: 0; }
+}
+
+.node {
+  display: inline-flex;
+  align-items: stretch;
+  gap: 3px;
+  border-radius: 8px;
+  padding: 2px 4px;
+  cursor: pointer;
+  border: 1px solid transparent;
+  user-select: none;
+}
+
+.node.node--atomic-spacing {
+  padding-inline: 0;
+  margin-inline: -2px;
+  border-color: transparent;
+}
+
+.node:hover {
+  border-color: var(--butex-border, #e2e8f0);
+  background: var(--butex-node-hover, rgba(148, 163, 184, 0.08));
+}
+
+.node.selected {
+  background: var(--butex-node-selected-bg, rgba(13, 148, 136, 0.14));
+  border-color: var(--butex-node-selected-border, rgba(13, 148, 136, 0.45));
+}
+
+.node.range-highlight {
+  background: var(--butex-selection-bg, rgba(13, 148, 136, 0.34));
+  border-color: var(--butex-selection-border, rgba(15, 118, 110, 0.9));
+  box-shadow: inset 0 0 0 3px var(--butex-selection-border, rgba(15, 118, 110, 0.9)),
+    0 0 0 1px var(--butex-selection-border, rgba(15, 118, 110, 0.9));
+  position: relative;
+  z-index: 2;
+}
+
+.chain .slot.range-highlight + .node.range-highlight,
+.chain .node.range-highlight + .slot.range-highlight {
+  margin-inline: -1px;
+}
+
+.node-body {
+  display: inline-flex;
+  align-items: stretch;
+  gap: 0;
+  min-height: 1.6em;
+}
+
+.node-value {
+  font-size: 16px;
+  font-weight: 500;
+  line-height: 1.25;
+  display: inline-flex;
+  align-items: center;
+}
+
+.scripts {
+  display: flex;
+  flex-direction: column;
+  flex-shrink: 0;
+  justify-content: space-between;
+  align-items: center;
+  padding: 1px 0;
+  min-width: 0.75em;
+}
+
+.scripts.scripts--sup-only {
+  justify-content: flex-start;
+  padding-bottom: 2px;
+}
+
+.scripts.scripts--sub-only {
+  justify-content: flex-end;
+  padding-top: 2px;
+}
+
+.script-box {
+  min-height: 12px;
+  min-width: 10px;
+  border-radius: 4px;
+  border: 1px dashed var(--butex-script-border, #cbd5e1);
+  padding: 0 2px;
+  font-size: 0.68em;
+  line-height: 1.15;
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  background: var(--butex-script-bg, rgba(248, 250, 252, 0.95));
+  color: var(--butex-script-color, #475569);
+}
+
+.script-box .chain {
+  min-height: auto;
+}
+
+${DELIMITER_CSS}
+
+${FRAC_CSS}
+
+${SQRT_CSS}
+
+${MATRIX_ENV_CSS}
+
+${ATOMIC_COMMAND_CSS}
+
+${ATOMIC_OPERATOR_COMMAND_CSS}
+`.trim();
+
+// src/document/mathEditorAdapter.ts
+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 editorNodeToAstNode(node) {
+  let astNode;
+  if (node.kind === "char") {
+    astNode = new CharNode(node.expr);
+  } 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 === "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
+    }
+  };
+}
+function mathSourceFromEditorSession(session, mathMode = "$", closing = "$") {
+  const inner = renderArabicLatexFromSession(session);
+  if (mathMode === "$" || mathMode === "\\(") {
+    return mathMode + inner + closing;
+  }
+  if (mathMode === "$$" || mathMode === "\\[") {
+    if (!inner.includes("\n")) {
+      return `${mathMode}
+${inner}
+${closing}`;
+    }
+    return `${mathMode}
+${inner.split("\n").map((line) => `    ${line}`).join(" \\\\\n")}
+${closing}`;
+  }
+  return `${mathMode}
+    ${inner}
+${closing}`;
+}
+
+// src/document/render.ts
+function renderInlineLatex(inline) {
+  if (inline.kind === "text") {
+    return inline.text;
+  }
+  return inline.math ? renderMathNodeLatex(inline.math) : inline.source;
+}
+function renderInlinesLatex(inlines) {
+  return inlines.map((inline) => renderInlineLatex(inline)).join("");
+}
+function renderTextBlockLatex(block) {
+  return `${block.command}{${renderInlinesLatex(block.inlines)}}`;
+}
+function indent(value) {
+  return value.split("\n").map((line) => `  ${line}`).join("\n");
+}
+function renderListBlockLatex(block) {
+  const items = block.items.map((item) => {
+    const nested = item.blocks.map((child) => "\n" + indent(renderBlockLatex(child))).join("");
+    return `  \\item ${renderInlinesLatex(item.inlines)}${nested}`;
+  }).join("\n");
+  return `${block.command}
+${items}
+${block.closing}`;
+}
+function renderTableBlockLatex(block) {
+  const rows = block.rows.map((row) => `  ${row.map((cell) => renderInlinesLatex(cell)).join(" & ")}`).join(" \\\\\n");
+  return `${block.command}{${block.columns}}
+${rows}
+${block.closing}`;
+}
+function renderImageOptions(block) {
+  const entries = Object.entries(block.options);
+  if (entries.length === 0) {
+    return "";
+  }
+  return `[${entries.map(([key, value]) => `${key}=${value}`).join(",")}]`;
+}
+function renderBlockLatex(block) {
+  if (block.kind === "textBlock") {
+    return renderTextBlockLatex(block);
+  }
+  if (block.kind === "list") {
+    return renderListBlockLatex(block);
+  }
+  if (block.kind === "table") {
+    return renderTableBlockLatex(block);
+  }
+  if (block.kind === "image") {
+    return `${block.command}${renderImageOptions(block)}{${block.value}}`;
+  }
+  return block.value;
+}
+function renderDocumentLatex(document2) {
+  return document2.blocks.map((block) => renderBlockLatex(block)).join("\n\n");
+}
+function escapeHtml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function renderPreviewInlines(inlines, islands) {
+  return inlines.map((inline) => {
+    if (inline.kind === "text") {
+      return escapeHtml(inline.text);
+    }
+    const tex = inline.math ? renderMathNodeLatex(inline.math) : inline.source;
+    const id = `math-${String(islands.length)}`;
+    const display = inline.math ? isDisplayMathNode(inline.math) : inline.source.startsWith("$$") || inline.source.startsWith("\\[") || inline.source.startsWith("\\begin{");
+    islands.push({ id, tex, display });
+    return `<span class="butex-document-math-island" data-math-id="${id}" data-math-display="${display ? "true" : "false"}">${escapeHtml(tex)}</span>`;
+  }).join("");
+}
+function renderPreviewBlock(block, islands) {
+  if (block.kind === "textBlock") {
+    const tagByCommand = {
+      "\\section": "h1",
+      "\\subsection": "h2",
+      "\\subsubsection": "h3",
+      "\\paragraph": "p"
+    };
+    const tag = tagByCommand[block.command];
+    return `<${tag}>${renderPreviewInlines(block.inlines, islands)}</${tag}>`;
+  }
+  if (block.kind === "list") {
+    const tag = block.command === "\\begin{enumerate}" ? "ol" : "ul";
+    const items = block.items.map((item) => {
+      const nested = item.blocks.map((child) => renderPreviewBlock(child, islands)).join("");
+      return `<li>${renderPreviewInlines(item.inlines, islands)}${nested}</li>`;
+    }).join("");
+    return `<${tag}>${items}</${tag}>`;
+  }
+  if (block.kind === "table") {
+    const rows = block.rows.map((row) => `<tr>${row.map((cell) => `<td>${renderPreviewInlines(cell, islands)}</td>`).join("")}</tr>`).join("");
+    return `<table><tbody>${rows}</tbody></table>`;
+  }
+  if (block.kind === "image") {
+    return `<img src="${escapeHtml(block.value)}" alt="" />`;
+  }
+  return `<pre>${escapeHtml(block.value)}</pre>`;
+}
+function buildDocumentPreview(document2) {
+  const mathIslands = [];
+  const html = document2.blocks.map((block) => renderPreviewBlock(block, mathIslands)).join("\n");
+  return { html, mathIslands };
+}
+
+// src/document/editing.ts
+function cloneDocument(document2) {
+  return {
+    nodeType: "DocumentObject",
+    blocks: document2.blocks.map(cloneBlock)
+  };
+}
+function cloneInlines(inlines) {
+  return inlines.map(
+    (inline) => inline.kind === "text" ? { kind: "text", text: inline.text } : { kind: "math", source: inline.source, math: inline.math }
+  );
+}
+function cloneListItem(item) {
+  return {
+    value: item.value,
+    inlines: cloneInlines(item.inlines),
+    blocks: item.blocks.map(cloneBlock)
+  };
+}
+function cloneBlock(block) {
+  if (block.kind === "textBlock") {
+    return { ...block, inlines: cloneInlines(block.inlines) };
+  }
+  if (block.kind === "list") {
+    return { ...block, items: block.items.map(cloneListItem) };
+  }
+  if (block.kind === "table") {
+    return {
+      ...block,
+      rows: block.rows.map((row) => row.map((cell) => cloneInlines(cell)))
+    };
+  }
+  if (block.kind === "image") {
+    return { ...block, options: { ...block.options } };
+  }
+  return { ...block };
+}
+function inlinesToValue(inlines) {
+  return inlines.map((inline) => inline.kind === "text" ? inline.text : inline.source).join("");
+}
+function textBlock(command, value = "") {
+  return { kind: "textBlock", command, value, inlines: buildInlines(value) };
+}
+function listBlock(command) {
+  return {
+    kind: "list",
+    command,
+    closing: command === "\\begin{itemize}" ? "\\end{itemize}" : "\\end{enumerate}",
+    items: [{ value: "", inlines: buildInlines(""), blocks: [] }]
+  };
+}
+function tableBlock() {
+  return {
+    kind: "table",
+    command: "\\begin{tabular}",
+    closing: "\\end{tabular}",
+    columns: "cc",
+    rows: [
+      [buildInlines(""), buildInlines("")],
+      [buildInlines(""), buildInlines("")]
+    ]
+  };
+}
+function imageBlock() {
+  return { kind: "image", command: "\\includegraphics", value: "", options: {} };
+}
+function rawBlock() {
+  return { kind: "raw", command: "\\raw", value: "" };
+}
+function createDocumentBlock(kind) {
+  if (kind === "section") {
+    return textBlock("\\section");
+  }
+  if (kind === "subsection") {
+    return textBlock("\\subsection");
+  }
+  if (kind === "subsubsection") {
+    return textBlock("\\subsubsection");
+  }
+  if (kind === "paragraph") {
+    return textBlock("\\paragraph");
+  }
+  if (kind === "itemize") {
+    return listBlock("\\begin{itemize}");
+  }
+  if (kind === "enumerate") {
+    return listBlock("\\begin{enumerate}");
+  }
+  if (kind === "table") {
+    return tableBlock();
+  }
+  if (kind === "image") {
+    return imageBlock();
+  }
+  return rawBlock();
+}
+function addDocumentBlock(document2, kind) {
+  const next = cloneDocument(document2);
+  next.blocks.push(createDocumentBlock(kind));
+  return next;
+}
+function removeDocumentBlock(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  next.blocks.splice(blockIndex, 1);
+  return next;
+}
+function moveDocumentBlock(document2, blockIndex, direction) {
+  const next = cloneDocument(document2);
+  const targetIndex = blockIndex + direction;
+  if (blockIndex < 0 || targetIndex < 0 || blockIndex >= next.blocks.length || targetIndex >= next.blocks.length) {
+    return document2;
+  }
+  const [block] = next.blocks.splice(blockIndex, 1);
+  if (!block) {
+    return document2;
+  }
+  next.blocks.splice(targetIndex, 0, block);
+  return next;
+}
+function updateTextBlockValue(document2, blockIndex, value) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "textBlock") {
+    return document2;
+  }
+  block.value = value;
+  block.inlines = buildInlines(value);
+  return next;
+}
+function updateRawBlockValue(document2, blockIndex, value) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "raw") {
+    return document2;
+  }
+  block.value = value;
+  return next;
+}
+function updateImageBlock(document2, blockIndex, value, options) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "image") {
+    return document2;
+  }
+  block.value = value;
+  block.options = options;
+  return next;
+}
+function updateListItemValue(document2, blockIndex, itemIndex, value) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "list" || !block.items[itemIndex]) {
+    return document2;
+  }
+  block.items[itemIndex].value = value;
+  block.items[itemIndex].inlines = buildInlines(value);
+  return next;
+}
+function addListItem(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "list") {
+    return document2;
+  }
+  block.items.push({ value: "", inlines: buildInlines(""), blocks: [] });
+  return next;
+}
+function removeListItem(document2, blockIndex, itemIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "list" || block.items.length <= 1) {
+    return document2;
+  }
+  block.items.splice(itemIndex, 1);
+  return next;
+}
+function addNestedListBlock(document2, blockIndex, itemIndex, kind) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  const item = block?.kind === "list" ? block.items[itemIndex] : null;
+  if (!item) {
+    return document2;
+  }
+  item.blocks.push(createDocumentBlock(kind));
+  return next;
+}
+function updateTableCell(document2, blockIndex, rowIndex, columnIndex, value) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table" || !block.rows[rowIndex] || !block.rows[rowIndex][columnIndex]) {
+    return document2;
+  }
+  block.rows[rowIndex][columnIndex] = buildInlines(value);
+  return next;
+}
+function updateTableColumns(document2, blockIndex, columns) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table") {
+    return document2;
+  }
+  block.columns = columns;
+  return next;
+}
+function addTableRow(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table") {
+    return document2;
+  }
+  const columns = Math.max(1, block.rows[0]?.length ?? 1);
+  block.rows.push(Array.from({ length: columns }, () => buildInlines("")));
+  return next;
+}
+function removeTableRow(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table" || block.rows.length <= 1) {
+    return document2;
+  }
+  block.rows.pop();
+  return next;
+}
+function addTableColumn(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table") {
+    return document2;
+  }
+  for (const row of block.rows) {
+    row.push(buildInlines(""));
+  }
+  block.columns += "c";
+  return next;
+}
+function removeTableColumn(document2, blockIndex) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[blockIndex];
+  if (!block || block.kind !== "table" || (block.rows[0]?.length ?? 0) <= 1) {
+    return document2;
+  }
+  for (const row of block.rows) {
+    row.pop();
+  }
+  block.columns = block.columns.slice(0, -1);
+  return next;
+}
+function mathInlineFromMathNode(math) {
+  return { kind: "math", source: renderMathNodeLatex(math), math };
+}
+function replaceInlinesMath(inlines, spanIndex, source, math = null) {
+  let mathIndex = 0;
+  return inlines.map((inline) => {
+    if (inline.kind !== "math") {
+      return inline;
+    }
+    if (mathIndex === spanIndex) {
+      mathIndex += 1;
+      return { kind: "math", source, math };
+    }
+    mathIndex += 1;
+    return inline;
+  });
+}
+function replaceMathSpan(document2, target, source, math) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[target.blockIndex];
+  if (!block) {
+    return document2;
+  }
+  if (target.scope === "block" && block.kind === "textBlock") {
+    block.inlines = replaceInlinesMath(block.inlines, target.spanIndex, source, math);
+    block.value = inlinesToValue(block.inlines);
+    return next;
+  }
+  if (target.scope === "listItem" && block.kind === "list") {
+    const item = block.items[target.itemIndex];
+    if (!item) {
+      return document2;
+    }
+    item.inlines = replaceInlinesMath(item.inlines, target.spanIndex, source, math);
+    item.value = inlinesToValue(item.inlines);
+    return next;
+  }
+  if (target.scope === "tableCell" && block.kind === "table") {
+    const cell = block.rows[target.rowIndex]?.[target.columnIndex];
+    if (!cell) {
+      return document2;
+    }
+    block.rows[target.rowIndex][target.columnIndex] = replaceInlinesMath(cell, target.spanIndex, source, math);
+    return next;
+  }
+  return document2;
+}
+function replaceMathSpanSource(document2, target, source) {
+  return replaceMathSpan(document2, target, source, null);
+}
+function replaceMathSpanFromEditor(document2, target, math, source) {
+  return replaceMathSpan(document2, target, source ?? renderMathNodeLatex(math), math);
+}
+function insertInlineAt(inlines, index, inline) {
+  const value = inlinesToValue(inlines);
+  const safeIndex = Math.max(0, Math.min(index, value.length));
+  const before = value.slice(0, safeIndex);
+  const after = value.slice(safeIndex);
+  const next = [];
+  if (before) {
+    next.push(...buildInlines(before));
+  }
+  next.push(inline);
+  if (after) {
+    next.push(...buildInlines(after));
+  }
+  return next;
+}
+function insertMathSpanFromEditor(document2, target, insertAt, math, source) {
+  const next = cloneDocument(document2);
+  const block = next.blocks[target.blockIndex];
+  if (!block) {
+    return document2;
+  }
+  const inline = source ? { kind: "math", source, math } : mathInlineFromMathNode(math);
+  if (target.scope === "block" && block.kind === "textBlock") {
+    block.inlines = insertInlineAt(block.inlines, insertAt, inline);
+    block.value = inlinesToValue(block.inlines);
+    return next;
+  }
+  if (target.scope === "listItem" && block.kind === "list") {
+    const item = block.items[target.itemIndex];
+    if (!item) {
+      return document2;
+    }
+    item.inlines = insertInlineAt(item.inlines, insertAt, inline);
+    item.value = inlinesToValue(item.inlines);
+    return next;
+  }
+  if (target.scope === "tableCell" && block.kind === "table") {
+    const cell = block.rows[target.rowIndex]?.[target.columnIndex];
+    if (!cell) {
+      return document2;
+    }
+    block.rows[target.rowIndex][target.columnIndex] = insertInlineAt(cell, insertAt, inline);
+    return next;
+  }
+  return document2;
+}
+function documentInlineText(inlines) {
+  return inlinesToValue(inlines);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addDocumentBlock,
+  addListItem,
+  addNestedListBlock,
+  addTableColumn,
+  addTableRow,
+  buildDocumentPreview,
+  buildInlines,
+  createDocumentBlock,
+  createEmptyDocument,
+  createImageBlock,
+  createListBlock,
+  createRawBlock,
+  createTableBlock,
+  createTextBlock,
+  detectMathSpans,
+  documentInlineText,
+  fromDocumentJson,
+  fromMathObjectJson,
+  insertMathSpanFromEditor,
+  isDisplayMathNode,
+  isSupportedDocumentCommand,
+  mathNodeFromEditorSession,
+  mathSourceFromEditorSession,
+  moveDocumentBlock,
+  removeDocumentBlock,
+  removeListItem,
+  removeTableColumn,
+  removeTableRow,
+  renderDocumentLatex,
+  renderMathNodeLatex,
+  replaceMathSpanFromEditor,
+  replaceMathSpanSource,
+  updateImageBlock,
+  updateListItemValue,
+  updateRawBlockValue,
+  updateTableCell,
+  updateTableColumns,
+  updateTextBlockValue
+});
+//# sourceMappingURL=document.js.map