katex4arabic 1.1.1

package/dist/lib/render.cjs

@@ -0,0 +1,811 @@
+"use strict";
+const katex = require("katex");
+const ARABIC_INDIC = ["٠", "١", "٢", "٣", "٤", "٥", "٦", "٧", "٨", "٩"];
+const EXTENDED_ARABIC = ["۰", "۱", "۲", "۳", "۴", "۵", "۶", "۷", "۸", "۹"];
+const DIGIT_MAP = {
+  arabic: ARABIC_INDIC,
+  extended: EXTENDED_ARABIC
+};
+function toArabicNumerals(input, style = "arabic") {
+  if (style === "latin") return String(input);
+  const digits = DIGIT_MAP[style];
+  return String(input).replace(/[0-9]/g, (d) => digits[Number(d)]);
+}
+function fromArabicNumerals(input) {
+  return String(input).replace(/[٠-٩]/g, (d) => String(ARABIC_INDIC.indexOf(d))).replace(/[۰-۹]/g, (d) => String(EXTENDED_ARABIC.indexOf(d)));
+}
+function formatArabicNumber(numStr) {
+  return numStr.replace(/,/g, "٬").replace(/\./g, "٫").replace(/[0-9]/g, (d) => ARABIC_INDIC[Number(d)]);
+}
+function convertNumbersInText(text, style = "arabic", formatSeparators = true) {
+  if (style === "latin") return text;
+  return text.replace(/\d+(?:[.,]\d+)*/g, (match) => {
+    if (formatSeparators) {
+      return formatArabicNumber(match);
+    }
+    return toArabicNumerals(match, style);
+  });
+}
+function isArabicDigit(ch) {
+  return /[٠-٩۰-۹]/.test(ch);
+}
+const VERBATIM_MACROS = [
+  "text",
+  "textnormal",
+  "textbf",
+  "textit",
+  "textrm",
+  "mathrm",
+  "mathbf",
+  "mathit",
+  "mathtt",
+  "mathsf",
+  "mathscr",
+  "mathfrak",
+  "mathbb",
+  "mathcal",
+  "color",
+  "textcolor",
+  "operatorname",
+  "operatorname*",
+  "operatornamewithlimits"
+];
+const VERBATIM_PATTERN = new RegExp(
+  `\\\\(?:${VERBATIM_MACROS.join("|")})\\{[^}]*\\}`,
+  "g"
+);
+function collectProtectedRegions(latex) {
+  const regions = [];
+  let m;
+  VERBATIM_PATTERN.lastIndex = 0;
+  while ((m = VERBATIM_PATTERN.exec(latex)) !== null) {
+    regions.push({ start: m.index, end: m.index + m[0].length });
+  }
+  regions.sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const r of regions) {
+    const last = merged[merged.length - 1];
+    if (last && r.start <= last.end) {
+      last.end = Math.max(last.end, r.end);
+    } else {
+      merged.push({ ...r });
+    }
+  }
+  return merged;
+}
+function isInsideRegions(pos, regions) {
+  for (const r of regions) {
+    if (pos >= r.start && pos < r.end) return true;
+    if (r.start > pos) break;
+  }
+  return false;
+}
+const FUNCTION_MAP = {
+  // ─── Basic trigonometric ─────────────────────────────────
+  "\\sin": "\\operatorname{جا}",
+  "\\cos": "\\operatorname{جتا}",
+  "\\tan": "\\operatorname{ظا}",
+  "\\cot": "\\operatorname{ظتا}",
+  "\\sec": "\\operatorname{قا}",
+  "\\csc": "\\operatorname{قتا}",
+  // ─── Inverse trigonometric ───────────────────────────────
+  "\\arcsin": "\\operatorname{جا}^{-1}",
+  "\\arccos": "\\operatorname{جتا}^{-1}",
+  "\\arctan": "\\operatorname{ظا}^{-1}",
+  "\\arccot": "\\operatorname{ظتا}^{-1}",
+  "\\arcsec": "\\operatorname{قا}^{-1}",
+  "\\arccsc": "\\operatorname{قتا}^{-1}",
+  // ─── Hyperbolic ──────────────────────────────────────────
+  "\\sinh": "\\operatorname{جـا}",
+  // جيب زائدي
+  "\\cosh": "\\operatorname{جتـا}",
+  // جيب تمام زائدي
+  "\\tanh": "\\operatorname{ظـا}",
+  // ظل زائدي
+  "\\coth": "\\operatorname{ظتـا}",
+  // ظل تمام زائدي
+  "\\sech": "\\operatorname{قـا}",
+  // قاطع زائدي
+  "\\csch": "\\operatorname{قتـا}",
+  // قاطع تمام زائدي
+  // ─── Logarithms & exponentials ───────────────────────────
+  "\\ln": "\\operatorname{لو}",
+  "\\log": "\\operatorname{لغ}",
+  "\\lg": "\\operatorname{لغ}",
+  // ─── Limits (kept as \arabiLim; translated separately) ───
+  "\\liminf": "\\operatorname*{نها}",
+  // ─── Maxima / minima ─────────────────────────────────────
+  "\\max": "\\operatorname*{أقصى}",
+  "\\min": "\\operatorname*{أدنى}",
+  "\\sup": "\\operatorname*{حد\\,أعلى}",
+  "\\inf": "\\operatorname*{حد\\,أدنى}",
+  // ─── Linear algebra ──────────────────────────────────────
+  "\\det": "\\operatorname{محدد}",
+  "\\dim": "\\operatorname{بعد}",
+  "\\ker": "\\operatorname{نواة}",
+  "\\rank": "\\operatorname{رتبة}",
+  "\\tr": "\\operatorname{أثر}",
+  "\\diag": "\\operatorname{قطري}",
+  "\\span": "\\operatorname{مدى}",
+  "\\null": "\\operatorname{فضاء\\,صفري}",
+  // ─── Number theory ───────────────────────────────────────
+  "\\gcd": "\\operatorname{ق.م.أ}",
+  "\\lcm": "\\operatorname{م.م.أ}",
+  "\\mod": "\\operatorname{باقي}",
+  "\\bmod": "\\operatorname{باقي}",
+  // ─── Probability & statistics ────────────────────────────
+  "\\Pr": "\\operatorname{حا}",
+  "\\P": "\\operatorname{حا}",
+  // ─── Complex & argument ──────────────────────────────────
+  "\\arg": "\\operatorname{سعة}",
+  "\\deg": "\\operatorname{درجة}",
+  "\\sgn": "\\operatorname{إشا}",
+  "\\Re": "\\operatorname{حق}",
+  "\\Im": "\\operatorname{تخ}",
+  "\\hom": "\\operatorname{تشا}",
+  "\\Hom": "\\operatorname{تشا}",
+  // ─── Special operator forms (preserved as-is) ────────────
+  // \sum, \prod, \int stay — they are mirrored visually via CSS.
+  "\\sum": "\\sum",
+  "\\prod": "\\prod",
+  "\\coprod": "\\coprod",
+  "\\int": "\\int",
+  "\\iint": "\\iint",
+  "\\iiint": "\\iiint",
+  "\\oint": "\\oint",
+  "\\partial": "\\partial",
+  "\\nabla": "\\nabla",
+  "\\infty": "\\infty",
+  "\\lim": "\\lim",
+  // processed via arabiLim pathway
+  "\\limsup": "\\operatorname*{نها}",
+  // ─── Special marker used internally for limit translation ─
+  // \arabiLim is a sentinel that the translator pipeline replaces
+  // with the proper \operatorname* form. Users normally do not write this.
+  "\\arabiLim": "\\operatorname*{نها}"
+  // '\\lim': '\\operatorname*{نها}',
+};
+const VARIABLE_MAP = {
+  // ─── Lowercase ───────────────────────────────────────────
+  x: "س",
+  y: "ص",
+  z: "ع",
+  a: "أ",
+  b: "ب",
+  c: "جـ",
+  d: "د",
+  e: "هـ",
+  // Euler's number
+  f: "ف",
+  g: "ق",
+  h: "ح",
+  i: "ت",
+  // imaginary unit
+  j: "ج",
+  k: "ك",
+  l: "ل",
+  m: "م",
+  n: "ن",
+  o: "ع",
+  p: "ب",
+  q: "ق",
+  r: "ر",
+  s: "ز",
+  t: "ت",
+  // u: 'ث',
+  // v: 'ڤ',
+  // w: 'و',
+  // ─── Uppercase ───────────────────────────────────────────
+  A: "أ",
+  B: "ب",
+  C: "جـ",
+  D: "د",
+  E: "هـ",
+  F: "ف",
+  G: "ق",
+  H: "ح",
+  I: "ت",
+  J: "ج",
+  K: "ك",
+  L: "ل",
+  M: "م",
+  N: "ن",
+  O: "ع",
+  P: "ح",
+  Q: "ق",
+  R: "ر",
+  S: "ز",
+  T: "ت",
+  U: "ث",
+  V: "ڤ",
+  W: "و",
+  X: "س",
+  Y: "ص",
+  Z: "ز"
+};
+const GREEK_MAP = {
+  "\\alpha": "α",
+  "\\beta": "β",
+  "\\gamma": "γ",
+  "\\delta": "δ",
+  "\\epsilon": "ε",
+  "\\varepsilon": "ε",
+  "\\zeta": "ζ",
+  "\\eta": "η",
+  "\\theta": "θ",
+  "\\vartheta": "ϑ",
+  "\\iota": "ι",
+  "\\kappa": "κ",
+  "\\lambda": "λ",
+  "\\mu": "μ",
+  "\\nu": "ν",
+  "\\xi": "ξ",
+  "\\pi": "π",
+  "\\varpi": "ϖ",
+  "\\rho": "ρ",
+  "\\varrho": "ϱ",
+  "\\sigma": "σ",
+  "\\varsigma": "ς",
+  "\\tau": "τ",
+  "\\upsilon": "υ",
+  "\\phi": "φ",
+  "\\varphi": "ϕ",
+  "\\chi": "χ",
+  "\\psi": "ψ",
+  "\\omega": "ω",
+  "\\Gamma": "Γ",
+  "\\Delta": "Δ",
+  "\\Theta": "Θ",
+  "\\Lambda": "Λ",
+  "\\Xi": "Ξ",
+  "\\Pi": "Π",
+  "\\Sigma": "Σ",
+  "\\Upsilon": "Υ",
+  "\\Phi": "Φ",
+  "\\Psi": "Ψ",
+  "\\Omega": "Ω"
+};
+const DIFFERENTIAL_PATTERNS = {
+  dx: "\\text{د}\\text{س}",
+  dy: "\\text{د}\\text{ص}",
+  dz: "\\text{د}\\text{ع}",
+  dt: "\\text{د}\\text{ز}",
+  dr: "\\text{د}\\text{ر}",
+  du: "\\text{د}\\text{ث}",
+  dv: "\\text{د}\\text{ڤ}",
+  ds: "\\text{د}\\text{س}",
+  dA: "\\text{د}\\text{أ}",
+  dV: "\\text{د}\\text{ح}",
+  dS: "\\text{د}\\text{س}"
+};
+function escapeRegex$1(input) {
+  return input.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function translateFunctions(latex, customMap = {}) {
+  const merged = { ...FUNCTION_MAP, ...customMap };
+  const protectedRegions = collectProtectedRegions(latex);
+  const cmdPattern = /\\[a-zA-Z]+/g;
+  let result = "";
+  let cursor = 0;
+  let m;
+  while ((m = cmdPattern.exec(latex)) !== null) {
+    const command = m[0];
+    const end = m.index + command.length;
+    const next = latex[end];
+    const followedByLetter = !!next && /[A-Za-z]/.test(next);
+    const replacement = followedByLetter ? void 0 : merged[command];
+    if (replacement !== void 0 && !isInsideRegions(m.index, protectedRegions)) {
+      result += latex.slice(cursor, m.index) + replacement;
+      cursor = end;
+      continue;
+    }
+    result += latex.slice(cursor, end);
+    cursor = end;
+  }
+  result += latex.slice(cursor);
+  return result;
+}
+function translateDifferentials(latex) {
+  let result = latex;
+  result = result.replace(
+    /\bd([xyztruvs])\b/g,
+    (_match, letter) => {
+      const arabic = VARIABLE_MAP[letter] ?? letter;
+      return `\\text{د}\\text{${arabic}}`;
+    }
+  );
+  result = result.replace(
+    /d\\(theta|phi|rho|alpha|beta|gamma|delta)\b/g,
+    (_match, greek) => `\\text{د}\\${greek}`
+  );
+  result = result.replace(
+    /\bd([AVS])\b/g,
+    (_match, letter) => {
+      const arabic = VARIABLE_MAP[letter] ?? letter;
+      return `\\text{د}\\text{${arabic}}`;
+    }
+  );
+  return result;
+}
+function translateVariables(latex, customMap = {}) {
+  const merged = { ...VARIABLE_MAP, ...customMap };
+  const keys = Object.keys(merged);
+  if (keys.length === 0) return latex;
+  const sorted = keys.sort((a, b) => b.length - a.length);
+  const protectedRegions = collectProtectedRegions(latex);
+  const pattern = new RegExp(
+    `(?<![A-Za-z\\\\])(${sorted.map(escapeRegex$1).join("|")})(?![A-Za-z])`,
+    "g"
+  );
+  return latex.replace(pattern, (match, _p1, offset, _string) => {
+    const pos = Number(offset);
+    if (isInsideRegions(pos, protectedRegions)) return match;
+    return `\\text{${merged[match]}}`;
+  });
+}
+function translateSpecialPatterns(latex) {
+  return translateDifferentials(latex);
+}
+function translateAll(latex, options = {}) {
+  const {
+    functions = true,
+    variables = true,
+    differentials = true,
+    customFunctionMap = {},
+    customVariableMap = {}
+  } = options;
+  let result = latex;
+  if (differentials) {
+    result = translateDifferentials(result);
+  }
+  if (functions) {
+    result = translateFunctions(result, customFunctionMap);
+  }
+  if (variables) {
+    result = translateVariables(result, customVariableMap);
+  }
+  return result;
+}
+const COMPARISON_MIRRORS = {
+  "<": ">",
+  ">": "<",
+  "\\lt": "\\gt",
+  "\\gt": "\\lt",
+  "\\leq": "\\geq",
+  "\\geq": "\\leq",
+  "\\le": "\\ge",
+  "\\ge": "\\le",
+  "\\leqslant": "\\geqslant",
+  "\\geqslant": "\\leqslant",
+  "\\lesssim": "\\gtrsim",
+  "\\gtrsim": "\\lesssim",
+  "\\ll": "\\gg",
+  "\\gg": "\\ll",
+  "\\nless": "\\ngtr",
+  "\\ngtr": "\\nless",
+  "\\nleq": "\\ngeq",
+  "\\ngeq": "\\nleq"
+};
+const ARROW_MIRRORS = {
+  "\\to": "\\gets",
+  "\\gets": "\\to",
+  "\\rightarrow": "\\leftarrow",
+  "\\leftarrow": "\\rightarrow",
+  "\\longrightarrow": "\\longleftarrow",
+  "\\longleftarrow": "\\longrightarrow",
+  "\\Rightarrow": "\\Leftarrow",
+  "\\Leftarrow": "\\Rightarrow",
+  "\\Longrightarrow": "\\Longleftarrow",
+  "\\Longleftarrow": "\\Longrightarrow",
+  "\\hookrightarrow": "\\hookleftarrow",
+  "\\hookleftarrow": "\\hookrightarrow",
+  "\\mapsto": "\\mapsfrom",
+  "\\mapsfrom": "\\mapsto",
+  "\\rightleftharpoons": "\\leftrightharpoons",
+  "\\leftrightharpoons": "\\rightleftharpoons"
+};
+const BRACKET_MIRRORS = {
+  "\\langle": "\\rangle",
+  "\\rangle": "\\langle",
+  "\\lceil": "\\rceil",
+  "\\rceil": "\\lceil",
+  "\\lfloor": "\\rfloor",
+  "\\rfloor": "\\lfloor",
+  "\\lbrace": "\\rbrace",
+  "\\rbrace": "\\lbrace",
+  "\\lbrack": "\\rbrack",
+  "\\rbrack": "\\lbrack"
+};
+const BIG_OP_MIRRORS = {
+  "\\sum": "\\sum",
+  // mirrored via CSS
+  "\\prod": "\\prod",
+  // mirrored via CSS
+  "\\int": "\\int",
+  // mirrored via CSS
+  "\\iint": "\\iint",
+  "\\iiint": "\\iiint",
+  "\\oint": "\\oint"
+};
+const MIRRORED_SYMBOLS = {
+  ...COMPARISON_MIRRORS,
+  ...ARROW_MIRRORS,
+  ...BRACKET_MIRRORS,
+  ...BIG_OP_MIRRORS
+};
+const COMPARISON_SYMBOLS = COMPARISON_MIRRORS;
+const ARROW_SYMBOLS = ARROW_MIRRORS;
+const BRACKET_SYMBOLS = BRACKET_MIRRORS;
+const ARABIC_MATH_UNICODE = {
+  alef: "𞸀",
+  ba: "𞸁",
+  jeem: "𞸂",
+  dal: "𞸃",
+  waw: "𞸅",
+  zain: "𞸆",
+  ha: "𞸇",
+  tah: "𞸈",
+  ya: "𞸉",
+  kaf: "𞸊",
+  lam: "𞸋",
+  meem: "𞸌",
+  noon: "𞸍",
+  seen: "𞸎",
+  ain: "𞸏",
+  fa: "𞸐",
+  sad: "𞸑",
+  qaf: "𞸒",
+  ra: "𞸓",
+  sheen: "𞸔",
+  ta: "𞸕",
+  tha: "𞸖",
+  kha: "𞸗",
+  dhal: "𞸘",
+  dad: "𞸙",
+  ghayn: "𞸚"
+};
+const SPECIAL_ARABIC_SYMBOLS = {
+  arabicFractionSlash: "/",
+  integralMaghribi: "\\int"
+  // mirrored visually via CSS
+};
+function escapeRegex(input) {
+  return input.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
+}
+function buildMirrorRegex(key) {
+  const escaped = escapeRegex(key);
+  if (key.length === 1) {
+    return new RegExp(`(?<![A-Za-z\\\\])${escaped}(?![A-Za-z])`, "g");
+  }
+  return new RegExp(escaped + "(?![A-Za-z])", "g");
+}
+function applyMirroredSymbols(latex, enabled = true) {
+  if (!enabled) return latex;
+  const sorted = Object.entries(MIRRORED_SYMBOLS).sort(
+    (a, b) => b[0].length - a[0].length
+  );
+  const pattern = new RegExp(
+    sorted.map(([key]) => `(?:${buildMirrorRegex(key).source})`).join("|"),
+    "g"
+  );
+  const mirrorByText = new Map(
+    sorted.map(([key, value]) => [key, value])
+  );
+  const protectedRegions = collectProtectedRegions(latex);
+  return latex.replace(pattern, (...args) => {
+    const match = args[0];
+    const offset = args[1];
+    if (isInsideRegions(offset, protectedRegions)) return match;
+    return mirrorByText.get(match) ?? match;
+  });
+}
+const MAX_INPUT_LENGTH = 2e4;
+const CACHE_CAPACITY = 256;
+class LruCache {
+  constructor(capacity) {
+    this.capacity = capacity;
+  }
+  capacity;
+  map = /* @__PURE__ */ new Map();
+  get(key) {
+    const value = this.map.get(key);
+    if (value !== void 0) {
+      this.map.delete(key);
+      this.map.set(key, value);
+    }
+    return value;
+  }
+  set(key, value) {
+    if (this.map.has(key)) {
+      this.map.delete(key);
+    } else if (this.map.size >= this.capacity) {
+      const firstKey = this.map.keys().next().value;
+      if (firstKey !== void 0) this.map.delete(firstKey);
+    }
+    this.map.set(key, value);
+  }
+  clear() {
+    this.map.clear();
+  }
+  get size() {
+    return this.map.size;
+  }
+}
+const renderCache = new LruCache(CACHE_CAPACITY);
+function clearRenderCache() {
+  renderCache.clear();
+}
+function buildCacheKey(latex, opts) {
+  return [
+    latex,
+    opts.numerals,
+    opts.formatNumbers,
+    opts.translateFuncs,
+    opts.translateVars,
+    opts.translateDiffs,
+    JSON.stringify(opts.customFunctionMap),
+    JSON.stringify(opts.customVariableMap),
+    opts.mirrorSymbols,
+    opts.mirrorBigOperators,
+    opts.mirrorSqrt,
+    opts.mirrorBrackets,
+    opts.direction,
+    opts.fontFamily,
+    opts.displayMode,
+    opts.fullArabicMode,
+    opts.operatorScale,
+    JSON.stringify(opts.macros),
+    opts.output,
+    String(opts.strict),
+    opts.trust,
+    opts.minRuleThickness
+  ].join("|");
+}
+const DEFAULT_OPTIONS = {
+  // Numerals
+  numerals: "arabic",
+  formatNumbers: true,
+  // Translation
+  translateFuncs: true,
+  translateVars: true,
+  translateDiffs: true,
+  customFunctionMap: {},
+  customVariableMap: {},
+  // Mirroring
+  mirrorSymbols: true,
+  mirrorBigOperators: true,
+  mirrorSqrt: true,
+  mirrorBrackets: true,
+  // Rendering
+  direction: "rtl",
+  fontFamily: "Amiri",
+  displayMode: false,
+  fullArabicMode: true,
+  // 1.05 compensates for the x-height difference between Arabic fonts
+  // (Amiri et al.) and KaTeX_Main, so Arabic operator names (جا، جتا…)
+  // visually match the size of their Latin counterparts out of the box.
+  operatorScale: 1.05,
+  // KaTeX
+  macros: {},
+  throwOnError: false,
+  output: "html",
+  strict: false,
+  trust: false,
+  minRuleThickness: 0.04
+};
+function resolveOptions(overrides = {}) {
+  return { ...DEFAULT_OPTIONS, ...overrides };
+}
+function processArabicLatex(latex, options = {}) {
+  const opts = resolveOptions(options);
+  let processed = latex.length > MAX_INPUT_LENGTH ? latex.slice(0, MAX_INPUT_LENGTH) : latex;
+  if (!processed.trim()) return processed;
+  if (opts.translateFuncs) {
+    processed = processed.replace(/\\lim(?![A-Za-z])/g, "\\arabiLim");
+  }
+  if (opts.translateDiffs) {
+    processed = translateDifferentials(processed);
+  }
+  if (opts.translateFuncs) {
+    processed = translateFunctions(processed, opts.customFunctionMap);
+  }
+  if (opts.translateVars) {
+    processed = translateVariables(processed, opts.customVariableMap);
+  }
+  if (opts.mirrorSymbols) {
+    processed = applyMirroredSymbols(processed, true);
+  }
+  if (opts.numerals !== "latin") {
+    processed = convertNumbersInLatex(processed, opts.numerals, opts.formatNumbers);
+  }
+  return processed;
+}
+function convertNumbersInLatex(latex, style, formatSeparators) {
+  let result = "";
+  let i = 0;
+  while (i < latex.length) {
+    const ch = latex[i];
+    if (ch && /[0-9]/.test(ch)) {
+      const prev = i > 0 ? latex[i - 1] : "";
+      if (prev && /[A-Za-z]/.test(prev)) {
+        result += ch;
+      } else {
+        let j = i;
+        while (j < latex.length) {
+          const cj = latex[j];
+          if (cj && /[0-9.,]/.test(cj)) {
+            j++;
+          } else {
+            break;
+          }
+        }
+        const run = latex.slice(i, j);
+        result += formatSeparators ? formatArabicNumber(run) : toArabicNumerals(run, style);
+        i = j;
+        continue;
+      }
+    } else {
+      result += ch ?? "";
+    }
+    i++;
+  }
+  return result;
+}
+function getArabicMacros(customMacros = {}) {
+  return {
+    // Trigonometric
+    "\\جا": "\\operatorname{جا}",
+    "\\جتا": "\\operatorname{جتا}",
+    "\\ظا": "\\operatorname{ظا}",
+    "\\ظتا": "\\operatorname{ظتا}",
+    "\\قا": "\\operatorname{قا}",
+    "\\قتا": "\\operatorname{قتا}",
+    // Logarithms
+    "\\لو": "\\operatorname{لو}",
+    "\\لغ": "\\operatorname{لغ}",
+    // Limits
+    "\\نها": "\\operatorname*{نها}",
+    "\\نهى": "\\operatorname*{نها}",
+    // Max/min
+    "\\اقصى": "\\operatorname*{أقصى}",
+    "\\ادنى": "\\operatorname*{أدنى}",
+    // Imaginary / constants
+    "\\ت": "\\text{ت}",
+    "\\هـ": "\\text{هـ}",
+    ...customMacros
+  };
+}
+function buildCssClasses(options) {
+  const opts = resolveOptions(options);
+  const classes = ["katex-arabic"];
+  if (opts.mirrorBigOperators) classes.push("mirror-big-ops");
+  if (opts.mirrorSqrt) classes.push("mirror-sqrt");
+  if (opts.mirrorBrackets) classes.push("mirror-brackets");
+  if (opts.mirrorSymbols) classes.push("mirror-symbols");
+  if (opts.fullArabicMode) classes.push("full-rtl-mode");
+  if (opts.displayMode) classes.push("is-display");
+  else classes.push("is-inline");
+  return classes;
+}
+function wrapWithArabicStyles(html, options) {
+  const opts = resolveOptions(options);
+  const classes = buildCssClasses(opts);
+  return `<span class="${classes.join(" ")}" dir="${opts.direction}" style="font-family:'${opts.fontFamily}','KaTeX_Main',serif;direction:${opts.direction};--ka-op-scale:${opts.operatorScale};">${html}</span>`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function renderArabicToString(latex, options = {}) {
+  return renderArabicWithMeta(latex, options).html;
+}
+function renderArabicWithMeta(latex, options = {}) {
+  const opts = resolveOptions(options);
+  const cacheKey = buildCacheKey(latex, opts);
+  const cached = renderCache.get(cacheKey);
+  if (cached !== void 0) {
+    return { html: cached, error: null };
+  }
+  const processedLatex = processArabicLatex(latex, opts);
+  try {
+    const html = katex.renderToString(processedLatex, {
+      displayMode: opts.displayMode,
+      throwOnError: true,
+      output: opts.output,
+      strict: opts.strict,
+      trust: opts.trust,
+      minRuleThickness: opts.minRuleThickness,
+      macros: {
+        ...getArabicMacros(opts.macros),
+        ...opts.macros ?? {}
+      }
+    });
+    const wrapped = wrapWithArabicStyles(html, opts);
+    renderCache.set(cacheKey, wrapped);
+    return { html: wrapped, error: null };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (opts.throwOnError) {
+      throw error instanceof Error ? error : new Error(message);
+    }
+    console.error("[katex-arabic] render failed:", message, "\nLaTeX:", latex);
+    return {
+      html: `<span class="katex-arabic katex-arabic--error" dir="rtl" role="alert" style="color:#dc2626;font-family:monospace;"><span class="katex-arabic__error-icon" aria-hidden="true">⚠</span> <span class="katex-arabic__error-text">${escapeHtml(latex)}</span></span>`,
+      error: message
+    };
+  }
+}
+function renderArabic(latex, element, options = {}) {
+  const html = renderArabicToString(latex, options);
+  element.innerHTML = html;
+  applyDomStyles(element, options);
+}
+function renderArabicBatch(items, options = {}) {
+  return items.map((item) => {
+    if (typeof item === "string") {
+      return renderArabicWithMeta(item, options);
+    }
+    return renderArabicWithMeta(item.latex, { ...options, ...item.options });
+  });
+}
+function processLatex(latex, options = {}) {
+  return processArabicLatex(latex, options);
+}
+function validateLatex(latex, options = {}) {
+  const opts = resolveOptions(options);
+  const processed = processArabicLatex(latex, opts);
+  try {
+    katex.renderToString(processed, {
+      displayMode: opts.displayMode,
+      throwOnError: true,
+      strict: opts.strict,
+      trust: opts.trust
+    });
+    return null;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+function applyDomStyles(element, options) {
+  const opts = resolveOptions(options);
+  const katexEl = element.querySelector(".katex");
+  if (katexEl) {
+    katexEl.setAttribute("dir", opts.direction);
+    katexEl.style.fontFamily = `'${opts.fontFamily}', 'KaTeX_Main', serif`;
+    katexEl.style.direction = opts.direction;
+  }
+}
+exports.ARABIC_MATH_UNICODE = ARABIC_MATH_UNICODE;
+exports.ARROW_SYMBOLS = ARROW_SYMBOLS;
+exports.BRACKET_SYMBOLS = BRACKET_SYMBOLS;
+exports.COMPARISON_SYMBOLS = COMPARISON_SYMBOLS;
+exports.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+exports.DIFFERENTIAL_PATTERNS = DIFFERENTIAL_PATTERNS;
+exports.FUNCTION_MAP = FUNCTION_MAP;
+exports.GREEK_MAP = GREEK_MAP;
+exports.MAX_INPUT_LENGTH = MAX_INPUT_LENGTH;
+exports.MIRRORED_SYMBOLS = MIRRORED_SYMBOLS;
+exports.SPECIAL_ARABIC_SYMBOLS = SPECIAL_ARABIC_SYMBOLS;
+exports.VARIABLE_MAP = VARIABLE_MAP;
+exports.applyMirroredSymbols = applyMirroredSymbols;
+exports.buildCssClasses = buildCssClasses;
+exports.clearRenderCache = clearRenderCache;
+exports.convertNumbersInText = convertNumbersInText;
+exports.formatArabicNumber = formatArabicNumber;
+exports.fromArabicNumerals = fromArabicNumerals;
+exports.getArabicMacros = getArabicMacros;
+exports.isArabicDigit = isArabicDigit;
+exports.processArabicLatex = processArabicLatex;
+exports.processLatex = processLatex;
+exports.renderArabic = renderArabic;
+exports.renderArabicBatch = renderArabicBatch;
+exports.renderArabicToString = renderArabicToString;
+exports.renderArabicWithMeta = renderArabicWithMeta;
+exports.resolveOptions = resolveOptions;
+exports.toArabicNumerals = toArabicNumerals;
+exports.translateAll = translateAll;
+exports.translateDifferentials = translateDifferentials;
+exports.translateFunctions = translateFunctions;
+exports.translateSpecialPatterns = translateSpecialPatterns;
+exports.translateVariables = translateVariables;
+exports.validateLatex = validateLatex;
+//# sourceMappingURL=render.cjs.map