katex4arabic 1.1.1

package/dist/lib/arabicFunctions.d.ts

@@ -0,0 +1,87 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  arabicFunctions.ts
+ *  Comprehensive translation dictionaries and transforms that
+ *  convert LaTeX function names, variables, and Greek letters
+ *  into their Arabic equivalents.
+ *
+ *  Design notes:
+ *   - All keys are LaTeX command names beginning with a backslash,
+ *     except for the VARIABLE_MAP which uses single letters.
+ *   - Translations never mutate the input. Each function returns
+ *     a new string.
+ *   - Regex safety: the `escapeRegex` helper protects against
+ *     special characters in keys when building dynamic patterns.
+ * ════════════════════════════════════════════════════════════════
+ */
+/**
+ * Map of LaTeX command → Arabic operator name.
+ * \operatorname* is used for operators with limits (e.g. lim, max, min).
+ * \operatorname is used for plain operator names.
+ */
+export declare const FUNCTION_MAP: Record<string, string>;
+/**
+ * Standard mapping of Latin letters to their conventional Arabic
+ * equivalents in mathematical literature. The uppercase forms follow
+ * the same scheme, with a few exceptions (e.g. E → هـ for Euler's
+ * constant, I → ت for the imaginary unit).
+ */
+export declare const VARIABLE_MAP: Record<string, string>;
+/**
+ * KaTeX renders Greek letters as native Unicode, so no translation
+ * is required. This table is provided for documentation and
+ * for users who want to inspect the supported set.
+ */
+export declare const GREEK_MAP: Record<string, string>;
+/**
+ * Convert a `dX` differential to Arabic form: `دX` where X is the
+ * Arabic variable. e.g. dx → د س, dθ → د θ.
+ */
+export declare const DIFFERENTIAL_PATTERNS: Record<string, string>;
+/**
+ * Translate LaTeX function commands (sin, cos, lim, …) to Arabic.
+ *
+ * Uses a single left-to-right scan of the source so that:
+ *   • the longest command wins at every position (\\arcsin before \\sin),
+ *   • verbatim regions (\\text{…}, \\operatorname{…}) are never modified,
+ *   • offsets stay stable — there is no cascade of in-place edits that
+ *     could re-shift later matches.
+ *
+ * @param latex     LaTeX source.
+ * @param customMap User-supplied overrides merged on top of FUNCTION_MAP.
+ */
+export declare function translateFunctions(latex: string, customMap?: Record<string, string>): string;
+/**
+ * Translate differential patterns like `dx`, `dy`, `d\theta` to their
+ * Arabic equivalents.
+ */
+export declare function translateDifferentials(latex: string): string;
+/**
+ * Translate standalone Latin variables to their Arabic equivalents.
+ *
+ * Critical: avoid translating inside LaTeX commands, math text blocks,
+ * and \\operatorname names. We pre-compute the "protected" regions once
+ * and run a single combined pass so that no offset ever shifts.
+ *
+ * Implementation note: the pattern has exactly one capture group, so the
+ * `replace` callback is `(match, p1, offset, string)` — `offset` is the
+ * **third** argument.
+ */
+export declare function translateVariables(latex: string, customMap?: Record<string, string>): string;
+/**
+ * Translate `d\theta` and other named Greek differentials to Arabic.
+ * Used by the differential pipeline; exposed for completeness.
+ */
+export declare function translateSpecialPatterns(latex: string): string;
+/**
+ * Translate everything: differentials, functions, and variables.
+ * Each step is independent and may be toggled by the caller.
+ */
+export declare function translateAll(latex: string, options?: {
+    functions?: boolean;
+    variables?: boolean;
+    differentials?: boolean;
+    customFunctionMap?: Record<string, string>;
+    customVariableMap?: Record<string, string>;
+}): string;
+//# sourceMappingURL=arabicFunctions.d.ts.map

package/dist/lib/arabicFunctions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabicFunctions.d.ts","sourceRoot":"","sources":["../../src/lib/katex-arabic/arabicFunctions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAQH;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwF/C,CAAC;AAMF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwD/C,CAAC;AAMF;;;;GAIG;AACH,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAW5C,CAAC;AAMF;;;GAGG;AACH,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAYxD,CAAC;AAkBF;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACrC,MAAM,CAgCR;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CA6B5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,SAAS,GAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAM,GACrC,MAAM,CAqBR;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE;IACP,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,iBAAiB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC,GACL,MAAM,CA6BR"}

package/dist/lib/arabicNumerals.d.ts

@@ -0,0 +1,50 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  arabicNumerals.ts
+ *  Convert Latin digits to Arabic-Indic / Persian digits, and
+ *  format numbers with proper Arabic separators.
+ *
+ *  Digit ranges:
+ *    - Arabic-Indic (٠-٩)   U+0660 – U+0669  (Standard Arabic)
+ *    - Eastern Arabic (۰-۹) U+06F0 – U+06F9  (Persian / Urdu)
+ * ════════════════════════════════════════════════════════════════
+ */
+import type { NumeralStyle } from './types';
+/**
+ * Converts a string of Latin digits to the requested numeral style.
+ * Returns the input unchanged when style is 'latin'.
+ *
+ * @param input  The text to convert.
+ * @param style  Target numeral style. Defaults to 'arabic'.
+ */
+export declare function toArabicNumerals(input: string | number, style?: NumeralStyle): string;
+/**
+ * Converts Arabic-Indic and Eastern-Arabic digits back to Latin.
+ * Useful for round-tripping or input normalization.
+ */
+export declare function fromArabicNumerals(input: string): string;
+/**
+ * Formats a numeric string with Arabic-Indic digits and Arabic separators:
+ *   - Thousands separator: ٬ (U+066C)
+ *   - Decimal separator:  ٫ (U+066B)
+ *
+ * Example: `1,000.50` → `١٬٠٠٠٫٥٠`
+ *
+ * Always uses the Arabic-Indic digit set, regardless of the requested style,
+ * because the Arabic separators are paired with that set in standard usage.
+ */
+export declare function formatArabicNumber(numStr: string): string;
+/**
+ * Convert all numeric substrings inside a text to the requested style.
+ * Optionally applies Arabic separators.
+ */
+export declare function convertNumbersInText(text: string, style?: NumeralStyle, formatSeparators?: boolean): string;
+/**
+ * Internal: returns true if the given character is any Arabic digit
+ * (Arabic-Indic or Eastern-Arabic).
+ *
+ * We rebuild a fresh regex per call to avoid the global-regex
+ * `lastIndex` state that would otherwise cause flaky results.
+ */
+export declare function isArabicDigit(ch: string): boolean;
+//# sourceMappingURL=arabicNumerals.d.ts.map

package/dist/lib/arabicNumerals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabicNumerals.d.ts","sourceRoot":"","sources":["../../src/lib/katex-arabic/arabicNumerals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAY5C;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,KAAK,GAAE,YAAuB,GAAG,MAAM,CAO/F;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKzD;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,KAAK,GAAE,YAAuB,EAC9B,gBAAgB,UAAO,GACtB,MAAM,CASR;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAEjD"}

package/dist/lib/arabicSymbols.d.ts

@@ -0,0 +1,52 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  arabicSymbols.ts
+ *  Symbol mirroring and Unicode math-symbol definitions.
+ *
+ *  When an equation is rendered in an RTL context, certain symbols
+ *  (≤, ≥, ∫, Σ, …) should appear visually mirrored so that the
+ *  smaller / open end faces the start of the reading direction.
+ *
+ *  This module is the *LaTeX-level* mirror. The CSS layer may
+ *  additionally apply `transform: scaleX(-1)` to the rendered
+ *  DOM nodes for finer-grained control over glyphs that KaTeX
+ *  renders directly (√, ∫, Σ, ∏).
+ * ════════════════════════════════════════════════════════════════
+ */
+/**
+ * Combined mirror map. Each group can be toggled independently.
+ */
+export declare const MIRRORED_SYMBOLS: Record<string, string>;
+/**
+ * Sub-maps exposed for fine-grained control by callers.
+ */
+export declare const COMPARISON_SYMBOLS: Record<string, string>;
+export declare const ARROW_SYMBOLS: Record<string, string>;
+export declare const BRACKET_SYMBOLS: Record<string, string>;
+/**
+ * The Unicode "Arabic Mathematical Alphabet" provides isolated-form
+ * Arabic letters optimized for math typesetting. These are *not*
+ * connecting forms; they are intended to behave like individual
+ * Latin letters inside an equation.
+ */
+export declare const ARABIC_MATH_UNICODE: Record<string, string>;
+/**
+ * Curated special symbols used in Arabic math typography.
+ */
+export declare const SPECIAL_ARABIC_SYMBOLS: {
+    readonly arabicFractionSlash: "/";
+    readonly integralMaghribi: "\\int";
+};
+/**
+ * Apply symbol mirroring to a LaTeX string.
+ *
+ * A single left-to-right pass over the *original* string is used. Each
+ * symbol is mapped at most once (so `<` never re-mirrors back to `<`),
+ * longer commands win over shorter prefixes, and verbatim regions are
+ * skipped — all without the offset-shift problems of chained passes.
+ *
+ * @param latex   LaTeX source.
+ * @param enabled Whether mirroring is active.
+ */
+export declare function applyMirroredSymbols(latex: string, enabled?: boolean): string;
+//# sourceMappingURL=arabicSymbols.d.ts.map

package/dist/lib/arabicSymbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arabicSymbols.d.ts","sourceRoot":"","sources":["../../src/lib/katex-arabic/arabicSymbols.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA+FH;;GAEG;AACH,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAKnD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,wBAAqB,CAAC;AACrD,eAAO,MAAM,aAAa,wBAAgB,CAAC;AAC3C,eAAO,MAAM,eAAe,wBAAkB,CAAC;AAM/C;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA2BtD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,sBAAsB;;;CAGzB,CAAC;AA2BX;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,UAAO,GAAG,MAAM,CAkC1E"}

package/dist/lib/cdn.d.ts

@@ -0,0 +1,18 @@
+/**
+ * cdn.ts
+ * Dedicated CDN entry point.
+ *
+ * The full `index.ts` barrel exports many named symbols; the CDN IIFE
+ * needs a *single* default export so that `window.KaTeXArabic` IS the
+ * namespace object (exactly like the `katex` global). This wrapper
+ * re-exports just that object.
+ *
+ * Everything the namespace needs is reachable through it:
+ *
+ *   KaTeXArabic.renderToString('...')
+ *   KaTeXArabic.render(el, '...')
+ *   KaTeXArabic.toArabicNumerals('123') → '١٢٣'
+ *   KaTeXArabic.DEFAULT_OPTIONS
+ */
+export { default } from './index';
+//# sourceMappingURL=cdn.d.ts.map

package/dist/lib/cdn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cdn.d.ts","sourceRoot":"","sources":["../../src/lib/katex-arabic/cdn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC"}

package/dist/lib/hooks.cjs

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const render = require("./render.cjs");
+const EMPTY_OPTIONS = Object.freeze({});
+function useArabicKatex(latex, options = EMPTY_OPTIONS) {
+  const deferredLatex = react.useDeferredValue(latex);
+  return react.useMemo(() => {
+    try {
+      return render.renderArabicWithMeta(deferredLatex, options).html;
+    } catch {
+      return "";
+    }
+  }, [deferredLatex, options]);
+}
+function useArabicKatexResult(latex, options = EMPTY_OPTIONS) {
+  const deferredLatex = react.useDeferredValue(latex);
+  return react.useMemo(() => {
+    const processedLatex = render.processArabicLatex(deferredLatex, options);
+    const { html, error } = render.renderArabicWithMeta(deferredLatex, options);
+    if (error !== null) {
+      return { html: "", processedLatex, ok: false, error };
+    }
+    return { html, processedLatex, ok: true };
+  }, [deferredLatex, options]);
+}
+function useArabicKatexBatch(items, options = EMPTY_OPTIONS) {
+  const itemsKey = react.useMemo(
+    () => items.map((it) => typeof it === "string" ? it : `${it.latex}|${JSON.stringify(it.options ?? {})}`).join("\0"),
+    [items]
+  );
+  return react.useMemo(
+    () => render.renderArabicBatch(items, options),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [itemsKey, options]
+  );
+}
+exports.useArabicKatex = useArabicKatex;
+exports.useArabicKatexBatch = useArabicKatexBatch;
+exports.useArabicKatexResult = useArabicKatexResult;
+//# sourceMappingURL=hooks.cjs.map

package/dist/lib/hooks.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.cjs","sources":["../../src/lib/katex-arabic/hooks.ts"],"sourcesContent":["/**\n * ════════════════════════════════════════════════════════════════\n *  hooks.ts\n *  React hooks for the KaTeX Arabic library.\n *\n *  These hooks memoize the rendered output and re-render only when\n *  inputs change. They are designed to integrate seamlessly with\n *  React 18+ concurrent rendering.\n *\n *  Performance notes:\n *   - A stable EMPTY_OPTIONS sentinel is used as the default so\n *     callers who omit `options` don't break memoization with a\n *     fresh object identity on every render.\n *   - `useArabicKatexResult` renders once and derives the error\n *     from the result instead of calling KaTeX twice.\n * ════════════════════════════════════════════════════════════════\n */\n\nimport { useMemo, useDeferredValue } from 'react';\nimport { renderArabicWithMeta, renderArabicBatch } from './render';\nimport { processArabicLatex } from './rtlRenderer';\nimport type { PartialArabicOptions, RenderResult } from './types';\n\n/**\n * Stable empty-options sentinel. Using a module-level constant as the\n * default parameter keeps the `options` identity stable across renders,\n * which is essential for the useMemo dependency check to work.\n */\nconst EMPTY_OPTIONS: PartialArabicOptions = Object.freeze({});\n\n/**\n * React hook: render a LaTeX string to HTML.\n *\n * The result is memoized on the (latex, options) identity. Heavy\n * renders use `useDeferredValue` so typing in an editor stays\n * responsive even for very long LaTeX strings.\n *\n * @param latex   The LaTeX source.\n * @param options Arabic rendering options.\n */\nexport function useArabicKatex(\n  latex: string,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): string {\n  // Defer the value to keep the UI responsive when the user is\n  // rapidly editing a long equation. The first render uses the\n  // current value, then subsequent renders may use the deferred\n  // one if React chooses to deprioritize the work.\n  const deferredLatex = useDeferredValue(latex);\n\n  return useMemo(() => {\n    try {\n      return renderArabicWithMeta(deferredLatex, options).html;\n    } catch {\n      // The renderer never throws (it returns a styled error string),\n      // but be defensive for unforeseen runtime errors.\n      return '';\n    }\n  }, [deferredLatex, options]);\n}\n\n/**\n * React hook: render LaTeX and return structured metadata.\n *\n * Returns both the rendered HTML and a flag indicating success,\n * along with any validation error message. Useful for editor UIs\n * that want to surface errors inline.\n *\n * Implementation: a single `renderArabicWithMeta` call yields both\n * the HTML and the error message, avoiding the double-render cost\n * of validate + render.\n */\nexport function useArabicKatexResult(\n  latex: string,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): RenderResult {\n  const deferredLatex = useDeferredValue(latex);\n\n  return useMemo<RenderResult>(() => {\n    const processedLatex = processArabicLatex(deferredLatex, options);\n    const { html, error } = renderArabicWithMeta(deferredLatex, options);\n\n    if (error !== null) {\n      return { html: '', processedLatex, ok: false, error };\n    }\n\n    return { html, processedLatex, ok: true };\n  }, [deferredLatex, options]);\n}\n\n/**\n * React hook: render a batch of LaTeX strings in one memoized pass.\n *\n * Returns an array of `{ html, error }` results in the same order as\n * the input. This is the most efficient way to render a list of\n * equations (e.g. a gallery) because the options object is resolved\n * once and the shared LRU cache is reused across the whole batch.\n *\n * @param items   Array of LaTeX strings (or `{ latex, options }` objects\n *                for per-item overrides).\n * @param options Shared options applied to every item unless overridden.\n */\nexport function useArabicKatexBatch(\n  items: ReadonlyArray<string | { latex: string; options?: PartialArabicOptions }>,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): Array<{ html: string; error: string | null }> {\n  // Serialize the items into a stable dependency so the memo only\n  // recomputes when the actual content changes, not on every render.\n  const itemsKey = useMemo(\n    () =>\n      items\n        .map((it) => (typeof it === 'string' ? it : `${it.latex}|${JSON.stringify(it.options ?? {})}`))\n        .join('\\u0000'),\n    [items],\n  );\n\n  return useMemo(\n    () => renderArabicBatch(items, options),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [itemsKey, options],\n  );\n}\n\n"],"names":["useDeferredValue","useMemo","renderArabicWithMeta","processArabicLatex","renderArabicBatch"],"mappings":";;;;AA4BA,MAAM,gBAAsC,OAAO,OAAO,EAAE;AAYrD,SAAS,eACd,OACA,UAAgC,eACxB;AAKR,QAAM,gBAAgBA,MAAAA,iBAAiB,KAAK;AAE5C,SAAOC,MAAAA,QAAQ,MAAM;AACnB,QAAI;AACF,aAAOC,4BAAqB,eAAe,OAAO,EAAE;AAAA,IACtD,QAAQ;AAGN,aAAO;AAAA,IACT;AAAA,EACF,GAAG,CAAC,eAAe,OAAO,CAAC;AAC7B;AAaO,SAAS,qBACd,OACA,UAAgC,eAClB;AACd,QAAM,gBAAgBF,MAAAA,iBAAiB,KAAK;AAE5C,SAAOC,MAAAA,QAAsB,MAAM;AACjC,UAAM,iBAAiBE,OAAAA,mBAAmB,eAAe,OAAO;AAChE,UAAM,EAAE,MAAM,MAAA,IAAUD,OAAAA,qBAAqB,eAAe,OAAO;AAEnE,QAAI,UAAU,MAAM;AAClB,aAAO,EAAE,MAAM,IAAI,gBAAgB,IAAI,OAAO,MAAA;AAAA,IAChD;AAEA,WAAO,EAAE,MAAM,gBAAgB,IAAI,KAAA;AAAA,EACrC,GAAG,CAAC,eAAe,OAAO,CAAC;AAC7B;AAcO,SAAS,oBACd,OACA,UAAgC,eACe;AAG/C,QAAM,WAAWD,MAAAA;AAAAA,IACf,MACE,MACG,IAAI,CAAC,OAAQ,OAAO,OAAO,WAAW,KAAK,GAAG,GAAG,KAAK,IAAI,KAAK,UAAU,GAAG,WAAW,CAAA,CAAE,CAAC,EAAG,EAC7F,KAAK,IAAQ;AAAA,IAClB,CAAC,KAAK;AAAA,EAAA;AAGR,SAAOA,MAAAA;AAAAA,IACL,MAAMG,OAAAA,kBAAkB,OAAO,OAAO;AAAA;AAAA,IAEtC,CAAC,UAAU,OAAO;AAAA,EAAA;AAEtB;;;;"}

package/dist/lib/hooks.d.cts

@@ -0,0 +1,61 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  hooks.ts
+ *  React hooks for the KaTeX Arabic library.
+ *
+ *  These hooks memoize the rendered output and re-render only when
+ *  inputs change. They are designed to integrate seamlessly with
+ *  React 18+ concurrent rendering.
+ *
+ *  Performance notes:
+ *   - A stable EMPTY_OPTIONS sentinel is used as the default so
+ *     callers who omit `options` don't break memoization with a
+ *     fresh object identity on every render.
+ *   - `useArabicKatexResult` renders once and derives the error
+ *     from the result instead of calling KaTeX twice.
+ * ════════════════════════════════════════════════════════════════
+ */
+import type { PartialArabicOptions, RenderResult } from './types';
+/**
+ * React hook: render a LaTeX string to HTML.
+ *
+ * The result is memoized on the (latex, options) identity. Heavy
+ * renders use `useDeferredValue` so typing in an editor stays
+ * responsive even for very long LaTeX strings.
+ *
+ * @param latex   The LaTeX source.
+ * @param options Arabic rendering options.
+ */
+export declare function useArabicKatex(latex: string, options?: PartialArabicOptions): string;
+/**
+ * React hook: render LaTeX and return structured metadata.
+ *
+ * Returns both the rendered HTML and a flag indicating success,
+ * along with any validation error message. Useful for editor UIs
+ * that want to surface errors inline.
+ *
+ * Implementation: a single `renderArabicWithMeta` call yields both
+ * the HTML and the error message, avoiding the double-render cost
+ * of validate + render.
+ */
+export declare function useArabicKatexResult(latex: string, options?: PartialArabicOptions): RenderResult;
+/**
+ * React hook: render a batch of LaTeX strings in one memoized pass.
+ *
+ * Returns an array of `{ html, error }` results in the same order as
+ * the input. This is the most efficient way to render a list of
+ * equations (e.g. a gallery) because the options object is resolved
+ * once and the shared LRU cache is reused across the whole batch.
+ *
+ * @param items   Array of LaTeX strings (or `{ latex, options }` objects
+ *                for per-item overrides).
+ * @param options Shared options applied to every item unless overridden.
+ */
+export declare function useArabicKatexBatch(items: ReadonlyArray<string | {
+    latex: string;
+    options?: PartialArabicOptions;
+}>, options?: PartialArabicOptions): Array<{
+    html: string;
+    error: string | null;
+}>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/hooks.d.ts

@@ -0,0 +1,61 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  hooks.ts
+ *  React hooks for the KaTeX Arabic library.
+ *
+ *  These hooks memoize the rendered output and re-render only when
+ *  inputs change. They are designed to integrate seamlessly with
+ *  React 18+ concurrent rendering.
+ *
+ *  Performance notes:
+ *   - A stable EMPTY_OPTIONS sentinel is used as the default so
+ *     callers who omit `options` don't break memoization with a
+ *     fresh object identity on every render.
+ *   - `useArabicKatexResult` renders once and derives the error
+ *     from the result instead of calling KaTeX twice.
+ * ════════════════════════════════════════════════════════════════
+ */
+import type { PartialArabicOptions, RenderResult } from './types';
+/**
+ * React hook: render a LaTeX string to HTML.
+ *
+ * The result is memoized on the (latex, options) identity. Heavy
+ * renders use `useDeferredValue` so typing in an editor stays
+ * responsive even for very long LaTeX strings.
+ *
+ * @param latex   The LaTeX source.
+ * @param options Arabic rendering options.
+ */
+export declare function useArabicKatex(latex: string, options?: PartialArabicOptions): string;
+/**
+ * React hook: render LaTeX and return structured metadata.
+ *
+ * Returns both the rendered HTML and a flag indicating success,
+ * along with any validation error message. Useful for editor UIs
+ * that want to surface errors inline.
+ *
+ * Implementation: a single `renderArabicWithMeta` call yields both
+ * the HTML and the error message, avoiding the double-render cost
+ * of validate + render.
+ */
+export declare function useArabicKatexResult(latex: string, options?: PartialArabicOptions): RenderResult;
+/**
+ * React hook: render a batch of LaTeX strings in one memoized pass.
+ *
+ * Returns an array of `{ html, error }` results in the same order as
+ * the input. This is the most efficient way to render a list of
+ * equations (e.g. a gallery) because the options object is resolved
+ * once and the shared LRU cache is reused across the whole batch.
+ *
+ * @param items   Array of LaTeX strings (or `{ latex, options }` objects
+ *                for per-item overrides).
+ * @param options Shared options applied to every item unless overridden.
+ */
+export declare function useArabicKatexBatch(items: ReadonlyArray<string | {
+    latex: string;
+    options?: PartialArabicOptions;
+}>, options?: PartialArabicOptions): Array<{
+    html: string;
+    error: string | null;
+}>;
+//# sourceMappingURL=hooks.d.ts.map

package/dist/lib/hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.ts","sourceRoot":"","sources":["../../src/lib/katex-arabic/hooks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,OAAO,KAAK,EAAE,oBAAoB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AASlE;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAoC,GAC5C,MAAM,CAgBR;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oBAAoC,GAC5C,YAAY,CAad;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,aAAa,CAAC,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,oBAAoB,CAAA;CAAE,CAAC,EAChF,OAAO,GAAE,oBAAoC,GAC5C,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAgB/C"}

package/dist/lib/hooks.mjs

@@ -0,0 +1,41 @@
+import { useDeferredValue, useMemo } from "react";
+import { r as renderArabicWithMeta, a as renderArabicBatch, p as processArabicLatex } from "./render.mjs";
+const EMPTY_OPTIONS = Object.freeze({});
+function useArabicKatex(latex, options = EMPTY_OPTIONS) {
+  const deferredLatex = useDeferredValue(latex);
+  return useMemo(() => {
+    try {
+      return renderArabicWithMeta(deferredLatex, options).html;
+    } catch {
+      return "";
+    }
+  }, [deferredLatex, options]);
+}
+function useArabicKatexResult(latex, options = EMPTY_OPTIONS) {
+  const deferredLatex = useDeferredValue(latex);
+  return useMemo(() => {
+    const processedLatex = processArabicLatex(deferredLatex, options);
+    const { html, error } = renderArabicWithMeta(deferredLatex, options);
+    if (error !== null) {
+      return { html: "", processedLatex, ok: false, error };
+    }
+    return { html, processedLatex, ok: true };
+  }, [deferredLatex, options]);
+}
+function useArabicKatexBatch(items, options = EMPTY_OPTIONS) {
+  const itemsKey = useMemo(
+    () => items.map((it) => typeof it === "string" ? it : `${it.latex}|${JSON.stringify(it.options ?? {})}`).join("\0"),
+    [items]
+  );
+  return useMemo(
+    () => renderArabicBatch(items, options),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [itemsKey, options]
+  );
+}
+export {
+  useArabicKatex,
+  useArabicKatexBatch,
+  useArabicKatexResult
+};
+//# sourceMappingURL=hooks.mjs.map

package/dist/lib/hooks.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.mjs","sources":["../../src/lib/katex-arabic/hooks.ts"],"sourcesContent":["/**\n * ════════════════════════════════════════════════════════════════\n *  hooks.ts\n *  React hooks for the KaTeX Arabic library.\n *\n *  These hooks memoize the rendered output and re-render only when\n *  inputs change. They are designed to integrate seamlessly with\n *  React 18+ concurrent rendering.\n *\n *  Performance notes:\n *   - A stable EMPTY_OPTIONS sentinel is used as the default so\n *     callers who omit `options` don't break memoization with a\n *     fresh object identity on every render.\n *   - `useArabicKatexResult` renders once and derives the error\n *     from the result instead of calling KaTeX twice.\n * ════════════════════════════════════════════════════════════════\n */\n\nimport { useMemo, useDeferredValue } from 'react';\nimport { renderArabicWithMeta, renderArabicBatch } from './render';\nimport { processArabicLatex } from './rtlRenderer';\nimport type { PartialArabicOptions, RenderResult } from './types';\n\n/**\n * Stable empty-options sentinel. Using a module-level constant as the\n * default parameter keeps the `options` identity stable across renders,\n * which is essential for the useMemo dependency check to work.\n */\nconst EMPTY_OPTIONS: PartialArabicOptions = Object.freeze({});\n\n/**\n * React hook: render a LaTeX string to HTML.\n *\n * The result is memoized on the (latex, options) identity. Heavy\n * renders use `useDeferredValue` so typing in an editor stays\n * responsive even for very long LaTeX strings.\n *\n * @param latex   The LaTeX source.\n * @param options Arabic rendering options.\n */\nexport function useArabicKatex(\n  latex: string,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): string {\n  // Defer the value to keep the UI responsive when the user is\n  // rapidly editing a long equation. The first render uses the\n  // current value, then subsequent renders may use the deferred\n  // one if React chooses to deprioritize the work.\n  const deferredLatex = useDeferredValue(latex);\n\n  return useMemo(() => {\n    try {\n      return renderArabicWithMeta(deferredLatex, options).html;\n    } catch {\n      // The renderer never throws (it returns a styled error string),\n      // but be defensive for unforeseen runtime errors.\n      return '';\n    }\n  }, [deferredLatex, options]);\n}\n\n/**\n * React hook: render LaTeX and return structured metadata.\n *\n * Returns both the rendered HTML and a flag indicating success,\n * along with any validation error message. Useful for editor UIs\n * that want to surface errors inline.\n *\n * Implementation: a single `renderArabicWithMeta` call yields both\n * the HTML and the error message, avoiding the double-render cost\n * of validate + render.\n */\nexport function useArabicKatexResult(\n  latex: string,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): RenderResult {\n  const deferredLatex = useDeferredValue(latex);\n\n  return useMemo<RenderResult>(() => {\n    const processedLatex = processArabicLatex(deferredLatex, options);\n    const { html, error } = renderArabicWithMeta(deferredLatex, options);\n\n    if (error !== null) {\n      return { html: '', processedLatex, ok: false, error };\n    }\n\n    return { html, processedLatex, ok: true };\n  }, [deferredLatex, options]);\n}\n\n/**\n * React hook: render a batch of LaTeX strings in one memoized pass.\n *\n * Returns an array of `{ html, error }` results in the same order as\n * the input. This is the most efficient way to render a list of\n * equations (e.g. a gallery) because the options object is resolved\n * once and the shared LRU cache is reused across the whole batch.\n *\n * @param items   Array of LaTeX strings (or `{ latex, options }` objects\n *                for per-item overrides).\n * @param options Shared options applied to every item unless overridden.\n */\nexport function useArabicKatexBatch(\n  items: ReadonlyArray<string | { latex: string; options?: PartialArabicOptions }>,\n  options: PartialArabicOptions = EMPTY_OPTIONS,\n): Array<{ html: string; error: string | null }> {\n  // Serialize the items into a stable dependency so the memo only\n  // recomputes when the actual content changes, not on every render.\n  const itemsKey = useMemo(\n    () =>\n      items\n        .map((it) => (typeof it === 'string' ? it : `${it.latex}|${JSON.stringify(it.options ?? {})}`))\n        .join('\\u0000'),\n    [items],\n  );\n\n  return useMemo(\n    () => renderArabicBatch(items, options),\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [itemsKey, options],\n  );\n}\n\n"],"names":[],"mappings":";;AA4BA,MAAM,gBAAsC,OAAO,OAAO,EAAE;AAYrD,SAAS,eACd,OACA,UAAgC,eACxB;AAKR,QAAM,gBAAgB,iBAAiB,KAAK;AAE5C,SAAO,QAAQ,MAAM;AACnB,QAAI;AACF,aAAO,qBAAqB,eAAe,OAAO,EAAE;AAAA,IACtD,QAAQ;AAGN,aAAO;AAAA,IACT;AAAA,EACF,GAAG,CAAC,eAAe,OAAO,CAAC;AAC7B;AAaO,SAAS,qBACd,OACA,UAAgC,eAClB;AACd,QAAM,gBAAgB,iBAAiB,KAAK;AAE5C,SAAO,QAAsB,MAAM;AACjC,UAAM,iBAAiB,mBAAmB,eAAe,OAAO;AAChE,UAAM,EAAE,MAAM,MAAA,IAAU,qBAAqB,eAAe,OAAO;AAEnE,QAAI,UAAU,MAAM;AAClB,aAAO,EAAE,MAAM,IAAI,gBAAgB,IAAI,OAAO,MAAA;AAAA,IAChD;AAEA,WAAO,EAAE,MAAM,gBAAgB,IAAI,KAAA;AAAA,EACrC,GAAG,CAAC,eAAe,OAAO,CAAC;AAC7B;AAcO,SAAS,oBACd,OACA,UAAgC,eACe;AAG/C,QAAM,WAAW;AAAA,IACf,MACE,MACG,IAAI,CAAC,OAAQ,OAAO,OAAO,WAAW,KAAK,GAAG,GAAG,KAAK,IAAI,KAAK,UAAU,GAAG,WAAW,CAAA,CAAE,CAAC,EAAG,EAC7F,KAAK,IAAQ;AAAA,IAClB,CAAC,KAAK;AAAA,EAAA;AAGR,SAAO;AAAA,IACL,MAAM,kBAAkB,OAAO,OAAO;AAAA;AAAA,IAEtC,CAAC,UAAU,OAAO;AAAA,EAAA;AAEtB;"}

package/dist/lib/index.cjs

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const render = require("./render.cjs");
+const VERSION = "1.1.1";
+const KaTeXArabic = {
+  // ─── Rendering ───────────────────────────────────────────
+  render: render.renderArabic,
+  renderToString: render.renderArabicToString,
+  renderWithMeta: render.renderArabicWithMeta,
+  renderBatch: render.renderArabicBatch,
+  // ─── Text processing ─────────────────────────────────────
+  process: render.processLatex,
+  validate: render.validateLatex,
+  // ─── Numerals ────────────────────────────────────────────
+  toArabicNumerals: render.toArabicNumerals,
+  fromArabicNumerals: render.fromArabicNumerals,
+  formatArabicNumber: render.formatArabicNumber,
+  convertNumbersInText: render.convertNumbersInText,
+  isArabicDigit: render.isArabicDigit,
+  // ─── Translation ─────────────────────────────────────────
+  translateFunctions: render.translateFunctions,
+  translateVariables: render.translateVariables,
+  translateDifferentials: render.translateDifferentials,
+  translateSpecialPatterns: render.translateSpecialPatterns,
+  translateAll: render.translateAll,
+  // ─── Mirroring ───────────────────────────────────────────
+  applyMirroredSymbols: render.applyMirroredSymbols,
+  // ─── Options / cache ─────────────────────────────────────
+  resolveOptions: render.resolveOptions,
+  buildCssClasses: render.buildCssClasses,
+  getArabicMacros: render.getArabicMacros,
+  clearCache: render.clearRenderCache,
+  DEFAULT_OPTIONS: render.DEFAULT_OPTIONS,
+  VERSION
+};
+exports.ARABIC_MATH_UNICODE = render.ARABIC_MATH_UNICODE;
+exports.ARROW_SYMBOLS = render.ARROW_SYMBOLS;
+exports.BRACKET_SYMBOLS = render.BRACKET_SYMBOLS;
+exports.COMPARISON_SYMBOLS = render.COMPARISON_SYMBOLS;
+exports.DEFAULT_OPTIONS = render.DEFAULT_OPTIONS;
+exports.DIFFERENTIAL_PATTERNS = render.DIFFERENTIAL_PATTERNS;
+exports.FUNCTION_MAP = render.FUNCTION_MAP;
+exports.GREEK_MAP = render.GREEK_MAP;
+exports.MAX_INPUT_LENGTH = render.MAX_INPUT_LENGTH;
+exports.MIRRORED_SYMBOLS = render.MIRRORED_SYMBOLS;
+exports.SPECIAL_ARABIC_SYMBOLS = render.SPECIAL_ARABIC_SYMBOLS;
+exports.VARIABLE_MAP = render.VARIABLE_MAP;
+exports.applyMirroredSymbols = render.applyMirroredSymbols;
+exports.buildCssClasses = render.buildCssClasses;
+exports.clearRenderCache = render.clearRenderCache;
+exports.convertNumbersInText = render.convertNumbersInText;
+exports.formatArabicNumber = render.formatArabicNumber;
+exports.fromArabicNumerals = render.fromArabicNumerals;
+exports.getArabicMacros = render.getArabicMacros;
+exports.isArabicDigit = render.isArabicDigit;
+exports.processLatex = render.processLatex;
+exports.renderArabic = render.renderArabic;
+exports.renderArabicBatch = render.renderArabicBatch;
+exports.renderArabicToString = render.renderArabicToString;
+exports.renderArabicWithMeta = render.renderArabicWithMeta;
+exports.resolveOptions = render.resolveOptions;
+exports.toArabicNumerals = render.toArabicNumerals;
+exports.translateAll = render.translateAll;
+exports.translateDifferentials = render.translateDifferentials;
+exports.translateFunctions = render.translateFunctions;
+exports.translateSpecialPatterns = render.translateSpecialPatterns;
+exports.translateVariables = render.translateVariables;
+exports.validateLatex = render.validateLatex;
+exports.VERSION = VERSION;
+exports.default = KaTeXArabic;
+//# sourceMappingURL=index.cjs.map

package/dist/lib/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../src/lib/katex-arabic/index.ts"],"sourcesContent":["/**\n * ════════════════════════════════════════════════════════════════\n *  index.ts\n *  Public entry point for the KaTeX Arabic library.\n *\n *  This module is the *only* file the application should import\n *  from when consuming the library. All internal modules are\n *  re-exported below for advanced use cases.\n *\n *  The render functions themselves live in `render.ts` so that\n *  `hooks.ts` can import them without a circular dependency\n *  through this barrel.\n * ════════════════════════════════════════════════════════════════\n */\n\nimport {\n  renderArabic,\n  renderArabicToString,\n  renderArabicWithMeta,\n  renderArabicBatch,\n  processLatex,\n  validateLatex,\n} from './render';\nimport {\n  DEFAULT_OPTIONS,\n  clearRenderCache,\n  resolveOptions,\n  buildCssClasses,\n  getArabicMacros,\n} from './rtlRenderer';\nimport {\n  toArabicNumerals,\n  fromArabicNumerals,\n  formatArabicNumber,\n  convertNumbersInText,\n  isArabicDigit,\n} from './arabicNumerals';\nimport {\n  translateFunctions,\n  translateVariables,\n  translateDifferentials,\n  translateSpecialPatterns,\n  translateAll,\n} from './arabicFunctions';\nimport { applyMirroredSymbols } from './arabicSymbols';\n\n// ─── Re-exports: configuration ─────────────────────────────\nexport {\n  DEFAULT_OPTIONS,\n  resolveOptions,\n  buildCssClasses,\n  getArabicMacros,\n  clearRenderCache,\n  MAX_INPUT_LENGTH,\n} from './rtlRenderer';\nexport type { ArabicKatexOptions, PartialArabicOptions, RenderResult } from './types';\n\n// ─── Re-exports: render functions ────────────────────────────\nexport {\n  renderArabicToString,\n  renderArabicWithMeta,\n  renderArabic,\n  renderArabicBatch,\n  processLatex,\n  validateLatex,\n} from './render';\n\n// ─── Re-exports: numerals ──────────────────────────────────\nexport {\n  toArabicNumerals,\n  fromArabicNumerals,\n  formatArabicNumber,\n  convertNumbersInText,\n  isArabicDigit,\n} from './arabicNumerals';\n\n// ─── Re-exports: function translation ──────────────────────\nexport {\n  translateFunctions,\n  translateVariables,\n  translateDifferentials,\n  translateSpecialPatterns,\n  translateAll,\n  FUNCTION_MAP,\n  VARIABLE_MAP,\n  GREEK_MAP,\n  DIFFERENTIAL_PATTERNS,\n} from './arabicFunctions';\n\n// ─── Re-exports: symbol mirroring ──────────────────────────\nexport {\n  applyMirroredSymbols,\n  MIRRORED_SYMBOLS,\n  COMPARISON_SYMBOLS,\n  ARROW_SYMBOLS,\n  BRACKET_SYMBOLS,\n  ARABIC_MATH_UNICODE,\n  SPECIAL_ARABIC_SYMBOLS,\n} from './arabicSymbols';\n\n// ─── Version constant ──────────────────────────────────────\n// Kept in sync with package.json by scripts/build-cdn.mjs\n// (the CDN build fails if these ever drift apart).\nexport const VERSION = '1.1.1';\n\n// ═══════════════════════════════════════════════════════════════\n//  Default export — the \"KaTeXArabic\" namespace\n//\n//  This object is what a CDN <script> tag exposes as `window.KaTeXArabic`,\n//  and what `import KaTeXArabic from 'katex-arabic'` returns. It mirrors\n//  `katex`'s own API shape (render / renderToString / …) plus every\n//  Arabic helper, so it works as a full drop-in namespace.\n// ═══════════════════════════════════════════════════════════════\n\nconst KaTeXArabic = {\n  // ─── Rendering ───────────────────────────────────────────\n  render: renderArabic,\n  renderToString: renderArabicToString,\n  renderWithMeta: renderArabicWithMeta,\n  renderBatch: renderArabicBatch,\n\n  // ─── Text processing ─────────────────────────────────────\n  process: processLatex,\n  validate: validateLatex,\n\n  // ─── Numerals ────────────────────────────────────────────\n  toArabicNumerals,\n  fromArabicNumerals,\n  formatArabicNumber,\n  convertNumbersInText,\n  isArabicDigit,\n\n  // ─── Translation ─────────────────────────────────────────\n  translateFunctions,\n  translateVariables,\n  translateDifferentials,\n  translateSpecialPatterns,\n  translateAll,\n\n  // ─── Mirroring ───────────────────────────────────────────\n  applyMirroredSymbols,\n\n  // ─── Options / cache ─────────────────────────────────────\n  resolveOptions,\n  buildCssClasses,\n  getArabicMacros,\n  clearCache: clearRenderCache,\n  DEFAULT_OPTIONS,\n  VERSION,\n};\n\nexport default KaTeXArabic;"],"names":["renderArabic","renderArabicToString","renderArabicWithMeta","renderArabicBatch","processLatex","validateLatex","toArabicNumerals","fromArabicNumerals","formatArabicNumber","convertNumbersInText","isArabicDigit","translateFunctions","translateVariables","translateDifferentials","translateSpecialPatterns","translateAll","applyMirroredSymbols","resolveOptions","buildCssClasses","getArabicMacros","clearRenderCache","DEFAULT_OPTIONS"],"mappings":";;;AAuGO,MAAM,UAAU;AAWvB,MAAM,cAAc;AAAA;AAAA,EAElB,QAAQA,OAAAA;AAAAA,EACR,gBAAgBC,OAAAA;AAAAA,EAChB,gBAAgBC,OAAAA;AAAAA,EAChB,aAAaC,OAAAA;AAAAA;AAAAA,EAGb,SAASC,OAAAA;AAAAA,EACT,UAAUC,OAAAA;AAAAA;AAAAA,EAAA,kBAGVC,OAAAA;AAAAA,EAAA,oBACAC,OAAAA;AAAAA,EAAA,oBACAC,OAAAA;AAAAA,EAAA,sBACAC,OAAAA;AAAAA,EAAA,eACAC,OAAAA;AAAAA;AAAAA,EAAA,oBAGAC,OAAAA;AAAAA,EAAA,oBACAC,OAAAA;AAAAA,EAAA,wBACAC,OAAAA;AAAAA,EAAA,0BACAC,OAAAA;AAAAA,EAAA,cACAC,OAAAA;AAAAA;AAAAA,EAAA,sBAGAC,OAAAA;AAAAA;AAAAA,EAAA,gBAGAC,OAAAA;AAAAA,EAAA,iBACAC,OAAAA;AAAAA,EAAA,iBACAC,OAAAA;AAAAA,EACA,YAAYC,OAAAA;AAAAA,EAAA,iBACZC,OAAAA;AAAAA,EACA;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/lib/index.d.cts

@@ -0,0 +1,53 @@
+/**
+ * ════════════════════════════════════════════════════════════════
+ *  index.ts
+ *  Public entry point for the KaTeX Arabic library.
+ *
+ *  This module is the *only* file the application should import
+ *  from when consuming the library. All internal modules are
+ *  re-exported below for advanced use cases.
+ *
+ *  The render functions themselves live in `render.ts` so that
+ *  `hooks.ts` can import them without a circular dependency
+ *  through this barrel.
+ * ════════════════════════════════════════════════════════════════
+ */
+import { renderArabic, renderArabicToString, renderArabicWithMeta, renderArabicBatch, processLatex, validateLatex } from './render';
+import { clearRenderCache, resolveOptions, buildCssClasses, getArabicMacros } from './rtlRenderer';
+import { toArabicNumerals, fromArabicNumerals, formatArabicNumber, convertNumbersInText, isArabicDigit } from './arabicNumerals';
+import { translateFunctions, translateVariables, translateDifferentials, translateSpecialPatterns, translateAll } from './arabicFunctions';
+import { applyMirroredSymbols } from './arabicSymbols';
+export { DEFAULT_OPTIONS, resolveOptions, buildCssClasses, getArabicMacros, clearRenderCache, MAX_INPUT_LENGTH, } from './rtlRenderer';
+export type { ArabicKatexOptions, PartialArabicOptions, RenderResult } from './types';
+export { renderArabicToString, renderArabicWithMeta, renderArabic, renderArabicBatch, processLatex, validateLatex, } from './render';
+export { toArabicNumerals, fromArabicNumerals, formatArabicNumber, convertNumbersInText, isArabicDigit, } from './arabicNumerals';
+export { translateFunctions, translateVariables, translateDifferentials, translateSpecialPatterns, translateAll, FUNCTION_MAP, VARIABLE_MAP, GREEK_MAP, DIFFERENTIAL_PATTERNS, } from './arabicFunctions';
+export { applyMirroredSymbols, MIRRORED_SYMBOLS, COMPARISON_SYMBOLS, ARROW_SYMBOLS, BRACKET_SYMBOLS, ARABIC_MATH_UNICODE, SPECIAL_ARABIC_SYMBOLS, } from './arabicSymbols';
+export declare const VERSION = "1.1.1";
+declare const KaTeXArabic: {
+    render: typeof renderArabic;
+    renderToString: typeof renderArabicToString;
+    renderWithMeta: typeof renderArabicWithMeta;
+    renderBatch: typeof renderArabicBatch;
+    process: typeof processLatex;
+    validate: typeof validateLatex;
+    toArabicNumerals: typeof toArabicNumerals;
+    fromArabicNumerals: typeof fromArabicNumerals;
+    formatArabicNumber: typeof formatArabicNumber;
+    convertNumbersInText: typeof convertNumbersInText;
+    isArabicDigit: typeof isArabicDigit;
+    translateFunctions: typeof translateFunctions;
+    translateVariables: typeof translateVariables;
+    translateDifferentials: typeof translateDifferentials;
+    translateSpecialPatterns: typeof translateSpecialPatterns;
+    translateAll: typeof translateAll;
+    applyMirroredSymbols: typeof applyMirroredSymbols;
+    resolveOptions: typeof resolveOptions;
+    buildCssClasses: typeof buildCssClasses;
+    getArabicMacros: typeof getArabicMacros;
+    clearCache: typeof clearRenderCache;
+    DEFAULT_OPTIONS: import("./types").ArabicKatexOptions;
+    VERSION: string;
+};
+export default KaTeXArabic;
+//# sourceMappingURL=index.d.ts.map