calkit-python 0.50.2__py3-none-any.whl → 0.50.3__py3-none-any.whl

calkit/cli/latex.py

@@ -11,7 +11,7 @@ import shutil
 import string
 import subprocess
 import sys
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from copy import deepcopy
 from pathlib import Path
 
@@ -1982,9 +1982,11 @@ def to_docx(
             "--engine",
             help=(
                 "What makes the Word copy: 'word', which imports the "
-                "compiled PDF so the copy looks like it, or 'libreoffice', "
+                "compiled PDF so the copy looks like it, 'libreoffice', "
                 "which converts the source with TeX4ht's make4ht and then "
-                "LibreOffice. Defaults to Word where it's installed."
+                "LibreOffice, or 'pandoc', experimental, which converts the "
+                "source with Pandoc, with numbers and citations from the "
+                "build. Defaults to Word where it's installed."
             ),
         ),
     ] = None,
@@ -2019,6 +2021,405 @@ def to_docx(
     from calkit.models.docx import LatexDocxExport
     from calkit.models.pipeline import LatexStage
 
+    def restore_formulas(
+        doc: calkit.docx.Document, blks: list[calkit.latex.Block]
+    ) -> None:
+        # A chemical formula, e.g., \ce{C3H8}, that Word's import drew
+        # partly as a picture, e.g., its subscripts, goes back as text
+        # formatted from the source
+        from xml.etree import ElementTree as ET
+
+        w_r = calkit.docx._tag(calkit.docx.W, "r")
+        w_t = calkit.docx._tag(calkit.docx.W, "t")
+        w_rpr = calkit.docx._tag(calkit.docx.W, "rPr")
+        w_vert = calkit.docx._tag(calkit.docx.W, "vertAlign")
+        by_name = {
+            calkit.latex.make_bookmark_name(b.path, b.lineno): b for b in blks
+        }
+        for p in doc.paragraphs:
+            # Without a numbered piece's suffix, e.g., ck_ab12_7_2
+            name = "_".join((p.bookmark or "").split("_")[:3])
+            fblk = by_name.get(name)
+            if fblk is None or p.element is None:
+                continue
+            src = calkit.latex._strip_comments_joined(
+                "\n".join(ln.text for ln in fblk.lines)
+            )
+            for fm in re.finditer(r"\\ce\s*\{((?:[^{}]|\{[^{}]*\})*)\}", src):
+                text = doc.linear_text(p.element)
+                if "\ufffc" not in text:
+                    break
+                formula = fm.group(1)
+                shown = calkit.latex.detex(f"\\ce{{{formula}}}")
+                before = calkit.latex.keep_letters_and_digits(
+                    calkit.latex.detex(src[: fm.start()])
+                )[-12:]
+                # The formula with some of it as the picture, after the
+                # prose before it
+                spot = None
+                for i in range(len(shown) + 1):
+                    for j in range(i, len(shown) + 1):
+                        pattern = (
+                            re.escape(shown[:i])
+                            + r"\s*\ufffc\s*"
+                            + re.escape(shown[j:])
+                        )
+                        for sm in re.finditer(pattern, text):
+                            if calkit.latex.keep_letters_and_digits(
+                                text[: sm.start()]
+                            ).endswith(before):
+                                spot = sm
+                                break
+                        if spot:
+                            break
+                    if spot:
+                        break
+                if spot is None:
+                    continue
+                # Its runs, as the text before it is set, with numbers
+                # after a symbol lowered and charges raised
+                pieces: list[tuple[str, str | None]] = []
+                k = 0
+                while k < len(formula):
+                    ch = formula[k]
+                    if ch in "^_" and k + 1 < len(formula):
+                        if formula[k + 1] == "{":
+                            close = formula.find("}", k + 2)
+                            close = len(formula) if close < 0 else close
+                            arg, k = formula[k + 2 : close], close + 1
+                        else:
+                            arg, k = formula[k + 1], k + 2
+                        pieces.append(
+                            (
+                                arg,
+                                "superscript" if ch == "^" else "subscript",
+                            )
+                        )
+                        continue
+                    if (
+                        ch.isdigit()
+                        and k
+                        and (
+                            formula[k - 1].isalpha() or formula[k - 1] in ")]"
+                        )
+                    ):
+                        end = k
+                        while end < len(formula) and formula[end].isdigit():
+                            end += 1
+                        pieces.append((formula[k:end], "subscript"))
+                        k = end
+                        continue
+                    if (
+                        ch in "+-"
+                        and k
+                        and formula[k - 1] not in " "
+                        and (k + 1 == len(formula) or formula[k + 1] == " ")
+                    ):
+                        pieces.append((ch, "superscript"))
+                        k += 1
+                        continue
+                    pieces.append((ch, None))
+                    k += 1
+                prior = [
+                    r for r in p.element.iter(w_r) if r.find(w_t) is not None
+                ]
+                offset = len(text[: spot.start()])
+                style = None
+                pos = 0
+                for r in prior:
+                    pos += len(doc._run_text(r))
+                    if pos >= offset:
+                        style = r.find(w_rpr)
+                        break
+                runs: list[tuple[str, str | None]] = []
+                for chunk, vert in pieces:
+                    if runs and runs[-1][1] == vert:
+                        runs[-1] = (runs[-1][0] + chunk, vert)
+                    else:
+                        runs.append((chunk, vert))
+                elements = []
+                for chunk, vert in runs:
+                    run = ET.Element(w_r)
+                    if style is not None:
+                        rpr = deepcopy(style)
+                        for old in rpr.findall(w_vert):
+                            rpr.remove(old)
+                        run.append(rpr)
+                    if vert is not None:
+                        has_rpr = run.find(w_rpr)
+                        rpr = (
+                            has_rpr
+                            if has_rpr is not None
+                            else ET.SubElement(run, w_rpr)
+                        )
+                        v = ET.Element(w_vert)
+                        v.set(calkit.docx._tag(calkit.docx.W, "val"), vert)
+                        # In schema order, before what follows it
+                        later = {
+                            calkit.docx._tag(calkit.docx.W, n)
+                            for n in (
+                                "rtl",
+                                "cs",
+                                "em",
+                                "lang",
+                                "eastAsianLayout",
+                                "specVanish",
+                                "oMath",
+                            )
+                        }
+                        rpr.insert(
+                            next(
+                                (
+                                    i
+                                    for i, c in enumerate(rpr)
+                                    if c.tag in later
+                                ),
+                                len(rpr),
+                            ),
+                            v,
+                        )
+                    t = ET.SubElement(run, w_t)
+                    t.text = chunk
+                    t.set(calkit.docx.XML_SPACE, "preserve")
+                    elements.append(run)
+                if elements and doc.replace_range(
+                    p.element, spot.start(), spot.end(), elements[0]
+                ):
+                    at = list(p.element).index(elements[0])
+                    for k, run in enumerate(elements[1:], 1):
+                        p.element.insert(at + k, run)
+                    doc._parents = {c: q for q in doc.doc.iter() for c in q}
+
+    def rebuild_tables(
+        doc: calkit.docx.Document,
+        paras: list[calkit.docx.Paragraph],
+        matched: list[calkit.latex.Block | None],
+        table_blks: list[calkit.latex.Block],
+        preamble: str,
+    ) -> tuple[dict[Any, calkit.latex.Block | None], set[int]]:
+        # Word's tables replaced by ones converted from the source, giving
+        # the block each paragraph is anchored to after and the ids of the
+        # blocks whose tables were replaced
+        rebuilt: set[int] = set()
+        from collections import Counter
+        from xml.etree import ElementTree as ET
+
+        w_body = doc.doc.find(calkit.docx._tag(calkit.docx.W, "body"))
+        assert w_body is not None
+        w_p = calkit.docx._tag(calkit.docx.W, "p")
+        w_tbl = calkit.docx._tag(calkit.docx.W, "tbl")
+        w_ppr = calkit.docx._tag(calkit.docx.W, "pPr")
+        w_sect_tag = calkit.docx._tag(calkit.docx.W, "sectPr")
+        w_sect = f"{w_ppr}/{w_sect_tag}"
+        block_of = {p.element: b for p, b in zip(paras, matched)}
+
+        def top_of(el: Any) -> Any:
+            while doc._parents.get(el) is not w_body:
+                el = doc._parents[el]
+            return el
+
+        def number(el: Any, attr: str, default: int) -> int:
+            value = el.get(attr) if el is not None else None
+            try:
+                return int(float(value)) if value else default
+            except ValueError:
+                return default
+
+        def is_prose(q: Any, blk: calkit.latex.Block) -> bool:
+            # Anchored elsewhere, and more than a cell's few words, which
+            # can match, e.g., a caption by chance
+            return (
+                block_of.get(q) not in (None, blk)
+                and len(doc.linear_text(q).split()) >= 4
+            )
+
+        def tokens(text: str) -> list[str]:
+            return re.findall(
+                r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])|\d+(?:\.\d+)?", text
+            )
+
+        # Each table's Word table to replace, and the width of the text
+        # where it is, as its section sets it
+        anchors: list[Any] = []
+        widths: list[int] = []
+        sizes: list[int | None] = []
+        for blk in table_blks:
+            mine = Counter(
+                top_of(p.element)
+                for p, b in zip(paras, matched)
+                if b is blk and p.element is not None
+            )
+            anchor = mine.most_common(1)[0][0] if mine else None
+            others = (
+                [q for q in anchor.iter(w_p) if is_prose(q, blk)]
+                if anchor is not None
+                else []
+            )
+            if (
+                anchor is None
+                or anchor.tag != w_tbl
+                or 3 * len(others) > mine[anchor]
+            ):
+                anchors.append(None)
+                widths.append(0)
+                sizes.append(None)
+                continue
+            anchors.append(anchor)
+            # In the size the PDF has it, as most of Word's runs in it are
+            sz = Counter(
+                el.get(calkit.docx._tag(calkit.docx.W, "val"))
+                for el in anchor.iter(calkit.docx._tag(calkit.docx.W, "sz"))
+            ).most_common(1)
+            sizes.append(
+                int(sz[0][0]) if sz and (sz[0][0] or "").isdigit() else None
+            )
+            children = list(w_body)
+            sect = next(
+                (
+                    c if c.tag == w_sect_tag else c.find(w_sect)
+                    for c in children[children.index(anchor) :]
+                    if c.tag == w_sect_tag or c.find(w_sect) is not None
+                ),
+                None,
+            )
+            width = 9360
+            if sect is not None:
+                size = sect.find(calkit.docx._tag(calkit.docx.W, "pgSz"))
+                margin = sect.find(calkit.docx._tag(calkit.docx.W, "pgMar"))
+                columns = sect.find(calkit.docx._tag(calkit.docx.W, "cols"))
+                w_attr = calkit.docx._tag(calkit.docx.W, "w")
+                n_cols = number(
+                    columns, calkit.docx._tag(calkit.docx.W, "num"), 1
+                )
+                width = (
+                    number(size, w_attr, 12240)
+                    - number(
+                        margin, calkit.docx._tag(calkit.docx.W, "left"), 1440
+                    )
+                    - number(
+                        margin, calkit.docx._tag(calkit.docx.W, "right"), 1440
+                    )
+                    - (n_cols - 1)
+                    * number(
+                        columns, calkit.docx._tag(calkit.docx.W, "space"), 720
+                    )
+                ) // max(1, n_cols)
+            widths.append(width)
+        tables = calkit.docx.latex_to_tables(
+            [
+                "\n".join(ln.text for ln in b.lines) if a is not None else ""
+                for b, a in zip(table_blks, anchors)
+            ],
+            preamble,
+            widths,
+            sizes,
+        )
+        for blk, table, anchor in zip(table_blks, tables, anchors):
+            if table is None or anchor is None:
+                continue
+            # Beside it, what's anchored to the table or reads only as its
+            # words, e.g., "Error Rate" from a header row
+            words = set(tokens(calkit.latex.detex(blk.text)))
+            children = list(w_body)
+            at = children.index(anchor)
+            going = [anchor]
+            for step in (-1, 1):
+                k = at + step
+                while 0 <= k < len(children):
+                    unit = children[k]
+                    # Its text runs, since a rule Word drew as a picture
+                    # can sit in the same paragraph
+                    text = "".join(
+                        t.text or ""
+                        for t in unit.iter(
+                            calkit.docx._tag(calkit.docx.W, "t")
+                        )
+                    )
+                    if unit.tag != w_p or unit.find(w_sect) is not None:
+                        break
+                    held = block_of.get(unit)
+                    if not (
+                        held is blk
+                        or (
+                            held is None
+                            and tokens(text)
+                            and set(tokens(text)) <= words
+                        )
+                    ):
+                        break
+                    going.append(unit)
+                    k += step
+            # Anchored prose inside Word's table moves out of it, before the
+            # table if it came first
+            inside = list(anchor.iter(w_p))
+            first_mine = next(
+                (i for i, q in enumerate(inside) if block_of.get(q) is blk), 0
+            )
+            moved = [
+                (i > first_mine, q)
+                for i, q in enumerate(inside)
+                if is_prose(q, blk)
+            ]
+            for _, q in moved:
+                doc._parents[q].remove(q)
+            at = list(w_body).index(anchor)
+            pieces = (
+                [q for after, q in moved if not after]
+                + [table]
+                + [q for after, q in moved if after]
+            )
+            for k, piece in enumerate(pieces):
+                w_body.insert(at + k, piece)
+            for unit in going:
+                w_body.remove(unit)
+            # Set off from the text after, as LaTeX sets a table
+            children = list(w_body)
+            after_tbl = children[children.index(table) + 1 :][:1]
+            if after_tbl and after_tbl[0].tag == w_p:
+                ppr = after_tbl[0].find(w_ppr)
+                if ppr is None:
+                    ppr = ET.Element(w_ppr)
+                    after_tbl[0].insert(0, ppr)
+                spacing = ppr.find(calkit.docx._tag(calkit.docx.W, "spacing"))
+                if spacing is None:
+                    spacing = ET.Element(
+                        calkit.docx._tag(calkit.docx.W, "spacing")
+                    )
+                    # In schema order, before what follows spacing
+                    later = {
+                        calkit.docx._tag(calkit.docx.W, t)
+                        for t in (
+                            "ind",
+                            "contextualSpacing",
+                            "mirrorIndents",
+                            "suppressOverlap",
+                            "jc",
+                            "textDirection",
+                            "textAlignment",
+                            "textboxTightWrap",
+                            "outlineLvl",
+                            "divId",
+                            "cnfStyle",
+                            "rPr",
+                            "sectPr",
+                            "pPrChange",
+                        )
+                    }
+                    ppr.insert(
+                        next(
+                            (k for k, c in enumerate(ppr) if c.tag in later),
+                            len(ppr),
+                        ),
+                        spacing,
+                    )
+                before_attr = calkit.docx._tag(calkit.docx.W, "before")
+                if int(spacing.get(before_attr, "0") or 0) < 240:
+                    spacing.set(before_attr, "240")
+            rebuilt.add(id(blk))
+            for q in table.iter(w_p):
+                block_of[q] = blk
+        return block_of, rebuilt
+
     ck_info = calkit.load_calkit_info()
     stages = ck_info.get("pipeline", {}).get("stages", {})
     stage_name = calkit.pipeline.get_stage_for_output(pdf_path, ck_info)
@@ -2054,10 +2455,13 @@ def to_docx(
         raise_error(f"{output} already exists; use --force to overwrite it")
     if engine is None:
         engine = "word" if calkit.docx.word_installed() else "libreoffice"
+    # Converted beside the output, then read in and removed, so a failed
+    # export doesn't leave the bare conversion where the export goes
+    bare = Path(output).with_suffix(".bare.docx").as_posix()
     if engine == "word":
         typer.echo("Converting the PDF with Word")
         try:
-            calkit.docx.pdf_to_docx(pdf_path, output)
+            calkit.docx.pdf_to_docx(pdf_path, bare)
         except RuntimeError as e:
             raise_error(
                 f"{e}\nTo convert from the source instead, use "
@@ -2210,16 +2614,135 @@ def to_docx(
                 f"{build}. Its make4ht comes with TeX Live's tex4ht package."
             )
         try:
-            calkit.docx.odt_to_docx(odt, output)
+            calkit.docx.odt_to_docx(odt, bare)
         except RuntimeError as e:
             raise_error(f"{e}\nTeX4ht's logs are in {build}")
+    elif engine == "pandoc":
+        import tempfile
+
+        if calkit.docx.find_pandoc() is None:
+            raise_error(
+                "Converting with Pandoc requires Pandoc; run "
+                "'calkit install pandoc'"
+            )
+        typer.echo("Converting the source with Pandoc")
+        # What TeX worked out, e.g., numbers and citations, comes from the
+        # build beside the PDF or the source
+        found_aux: dict[str, str] = {}
+        for ext in (".aux", ".bbl"):
+            for base in (Path(pdf_path), Path(source)):
+                picture = base.with_suffix(ext)
+                if picture.is_file():
+                    found_aux[ext] = picture.read_text(
+                        encoding="utf-8", errors="replace"
+                    )
+                    break
+        if ".aux" not in found_aux:
+            warn(
+                "No .aux beside the PDF or source, so references and "
+                "citations show as ??; build the document first"
+            )
+        tex_dir = Path(source).parent
+        drawn = tempfile.mkdtemp()
+
+        def find_image(path: str) -> str | None:
+            # A picture in the source as one Word can show, drawing a PDF
+            for picture in [tex_dir / path] + [
+                tex_dir / (path + ext)
+                for ext in (".pdf", ".png", ".jpg", ".jpeg")
+            ]:
+                if not picture.is_file():
+                    continue
+                if picture.suffix.lower() != ".pdf":
+                    return picture.resolve().as_posix()
+                png = os.path.join(
+                    drawn, f"{len(os.listdir(drawn))}-{picture.stem}.png"
+                )
+                if calkit.docx.pdf_to_png(str(picture), png):
+                    return png
+                warn(f"Couldn't draw {picture} for Word")
+                return None
+            return None
+
+        try:
+            text = calkit.latex.prepare_for_pandoc(
+                calkit.latex.flatten(source),
+                found_aux.get(".aux", ""),
+                found_aux.get(".bbl", ""),
+                find_image,
+            )
+            reference = os.path.join(drawn, "reference.docx")
+            Path(reference).write_bytes(calkit.docx.make_reference_doc())
+            pandoc_docx = calkit.docx._pandoc(
+                [
+                    "-f",
+                    "latex",
+                    "-t",
+                    "docx",
+                    "-o",
+                    "-",
+                    "--resource-path",
+                    tex_dir.as_posix() or ".",
+                    "--reference-doc",
+                    reference,
+                ],
+                text.encode(),
+            )
+        except RuntimeError as e:
+            raise_error(str(e))
+        finally:
+            shutil.rmtree(drawn, ignore_errors=True)
+        Path(bare).write_bytes(pandoc_docx)
     else:
-        raise_error("--engine must be 'word' or 'libreoffice'")
-    doc = calkit.docx.Document(output)
+        raise_error("--engine must be 'word', 'libreoffice', or 'pandoc'")
+    try:
+        doc = calkit.docx.Document(bare)
+    finally:
+        os.remove(bare)
+    doc.path = output
     lines = calkit.latex.flatten(source)
     blks = calkit.latex.blocks(lines)
+    # The document's macro definitions, for converting math and tables
+    preamble = "\n".join(
+        ln.text
+        for ln in lines
+        if re.match(
+            r"\s*\\(newcommand|renewcommand|providecommand|"
+            r"DeclareMathOperator|def)\b",
+            ln.text,
+        )
+    )
     paras = doc.paragraphs
     matched = calkit.latex.align([p.text for p in paras], blks)
+    # Tables come from the source too, converted by Pandoc, since Word's
+    # import can merge their rows, drop a header, or leave math as text.
+    # Each replaces the Word table holding most of its cells, with what
+    # Word put beside it from the table, e.g., a header row, and nothing
+    # anchored elsewhere.
+    rebuilt: set[int] = set()
+    table_blks = [
+        b
+        for b in blks
+        if b.display is None
+        and re.search(
+            r"\\begin\s*\{("
+            + "|".join(re.escape(e) for e in calkit.docx.TABLE_ENVS)
+            + r")\}",
+            "\n".join(ln.text for ln in b.lines),
+        )
+    ]
+    if (
+        engine in ("word", "pandoc")
+        and table_blks
+        and calkit.docx.find_pandoc() is not None
+    ):
+        block_of, rebuilt = rebuild_tables(
+            doc, paras, matched, table_blks, preamble
+        )
+        if rebuilt:
+            doc._parents = {c: p for p in doc.doc.iter() for c in p}
+            paras = doc.paragraphs
+            matched = [block_of.get(p.element) for p in paras]
     # Pieces of a paragraph Word's import split, e.g., at a page break,
     # join again, with anything floated between them after
     if engine == "word":
@@ -2396,6 +2919,21 @@ def to_docx(
                     for k in reversed(range(1, len(m.groups()) + 1)):
                         if not m.group(k):
                             doc.insert_text(para.element, m.start(k), "-")
+            # Likewise the space between a number and a word after it, e.g.,
+            # a unit, "20 K" as "20K", where the source never
+            # joins them
+            pairs = re.findall(
+                r"(?<![\w.])(\d+(?:[.,]\d+)*) ([^\W\d_]\w*)", blk.text
+            )
+            for num, word in dict.fromkeys(pairs):
+                joined = (
+                    rf"(?<![\w.]){re.escape(num)}(?={re.escape(word)}(?!\w))"
+                )
+                if re.search(joined, blk.text):
+                    continue
+                text = doc.linear_text(para.element)
+                for m in reversed(list(re.finditer(joined, text))):
+                    doc.insert_text(para.element, m.end(), " ")
         paras = doc.paragraphs
     # Bookmark each anchored paragraph; a block rendering as several
     # paragraphs gets numbered suffixes
@@ -2415,6 +2953,9 @@ def to_docx(
     # Display math goes in as Word equations converted from the source,
     # replacing what Word's PDF import or TeX4ht made of it
     equations: dict[str, str] = {}
+    # Inline math placed from the source, by element, with which of its
+    # block's inline math it is
+    placed_math: dict[int, tuple[Any, int]] = {}
     left_as_imported = 0
     has_display = any(b.display for b in blks)
     # Word's PDF import leaves inline math as text and pictures, which
@@ -2646,15 +3187,6 @@ def to_docx(
             for blk in group
             for k, (tex, numbered) in enumerate(blk.rows)
         ]
-        preamble = "\n".join(
-            ln.text
-            for ln in lines
-            if re.match(
-                r"\s*\\(newcommand|renewcommand|providecommand|"
-                r"DeclareMathOperator|def)\b",
-                ln.text,
-            )
-        )
         maths = calkit.docx.latex_to_omml([p[2] for p in pieces], preamble)
         converted = dict(zip([(id(p[0]), p[1]) for p in pieces], maths))
         # What each link within the document shows, e.g., an equation's
@@ -2883,10 +3415,26 @@ def to_docx(
             rendered = calkit.latex.keep_letters_and_digits(
                 calkit.latex.get_math_text(tex)
             )
+            # Or with big operators as the letters TeX's math extension
+            # font has them at, which Word's import can read, e.g., \sum as P
+            drawn = calkit.latex.keep_letters_and_digits(
+                calkit.latex.get_math_text(
+                    re.sub(
+                        r"\\(sum|prod|int|oint)(?![A-Za-z])",
+                        lambda m: {
+                            "sum": " P ",
+                            "prod": " Q ",
+                            "int": " R ",
+                        }.get(str(m.group(1)), " H "),
+                        tex,
+                    )
+                )
+            )
             return (
                 bool(region.strip())
                 and all(
                     calkit.latex.keep_letters_and_digits(w) in rendered
+                    or calkit.latex.keep_letters_and_digits(w) in drawn
                     for w in words
                 )
                 and set(re.findall(r"\d", region))
@@ -2956,11 +3504,12 @@ def to_docx(
             for p, b in zip(paras, matched):
                 if b is not None and p.element is not None:
                     by_block.setdefault(id(b), []).append(p.element)
+            math_index: dict[int, int] = {}
             for b in blks:
                 els = by_block.get(id(b), [])
                 texts = [doc.linear_text(el) for el in els]
                 pi, cursor = 0, 0
-                found = b.inline_math if els else []
+                found = b.inline_math if els and id(b) not in rebuilt else []
                 for n, (pre, tex, post) in enumerate(found):
                     # Only a superscript or subscript, e.g., $^{13}$C, stays
                     # as Word's formatted text, easier to edit
@@ -2974,8 +3523,13 @@ def to_docx(
                     )
                     # In the paragraph where the last one was, or a later
                     # one when the block continues past a page or float
+                    start_len = len(inline)
                     for k in range(pi, len(els)):
                         if place(k, pre, tex, shown, post, is_last):
+                            # Which of the block's inline math it is
+                            for j in range(start_len, len(inline)):
+                                if inline[j][3] is not None:
+                                    math_index[j] = n
                             break
             inline_maths = iter(
                 calkit.docx.latex_to_omml(
@@ -3002,6 +3556,8 @@ def to_docx(
                     s0, e0 = s0 + 1, e0 + 1
                 if doc.replace_range(el, s0, e0, math) and itex is not None:
                     inline_count += 1
+                    if math is not None and i in math_index:
+                        placed_math[id(math)] = (math, math_index[i])
                     # After a picture there was no text to put it in, so
                     # it starts the text after
                     if pad_trail and not trailed and math is not None:
@@ -3060,6 +3616,49 @@ def to_docx(
             for p in doc.paragraphs
             if p.bookmark and p.bookmark in original
         }
+    if engine == "word":
+        restore_formulas(doc, blks)
+        doc.prune_media()
+        original = {
+            p.bookmark: p.text
+            for p in doc.paragraphs
+            if p.bookmark and p.bookmark in original
+        }
+    # The inline math placed, as the converter reads it back, by paragraph,
+    # so a merge can tell what a reviewer changed in it
+    inline_eqs: dict[str, list[tuple[int, str]]] = {}
+    held_math: list[tuple[str | None, tuple[Any, int]]] = [
+        (p.bookmark, placed_math[id(child)])
+        for p in doc.paragraphs
+        if p.bookmark and p.element is not None
+        for child in p.element
+        if id(child) in placed_math
+    ]
+    # Converted with the document, a paragraph's inline math is its
+    # source's in order, where there are as many
+    if engine != "word":
+        by_mark = {
+            calkit.latex.make_bookmark_name(b.path, b.lineno): b
+            for b in blks
+            if not b.display
+        }
+        m_omath = calkit.docx._tag(calkit.docx.M, "oMath")
+        for p in doc.paragraphs:
+            mblk = by_mark.get(p.bookmark or "")
+            if mblk is None or p.element is None:
+                continue
+            found_math = [c for c in p.element if c.tag == m_omath]
+            if found_math and len(found_math) == len(mblk.inline_math):
+                held_math += [
+                    (p.bookmark, (el, k)) for k, el in enumerate(found_math)
+                ]
+    if held_math:
+        read_back_inline = calkit.docx.omml_to_latex(
+            [el for _, (el, _) in held_math]
+        )
+        for (mark, (_, index)), mtex in zip(held_math, read_back_inline):
+            if mtex is not None and mark is not None:
+                inline_eqs.setdefault(mark, []).append((index, mtex))
     doc.even_margins()
     # Existing comment blocks in the source go out as Word comments
     threads, anchors, highlights, resolved = [], [], [], []
@@ -3112,6 +3711,7 @@ def to_docx(
             original,
             doc.media_hashes,
             equations=equations,
+            inline=inline_eqs,
         )
     )
     doc.set_identifier(f"calkit-latex-export:{export_id}:{rev or ''}:{source}")
@@ -3209,7 +3809,10 @@ def merge_docx(
     comment blocks above the paragraph; threads resolved in Word are
     marked resolved.
     """
+    import dataclasses
     import datetime
+    import difflib
+    from typing import Any
 
     import calkit.docx
     import calkit.git
@@ -3246,6 +3849,19 @@ def merge_docx(
     }
     edits: dict[str, list[tuple[int, int, list[str]]]] = {}
     changes: list[LatexDocxMergeChange] = []
+    # Each block as edited so far, so edits to its pieces, e.g., a table's
+    # cells, or its text and its math, all apply
+    working: dict[int, calkit.latex.Block] = {}
+
+    def update(blk: calkit.latex.Block, new_lines: list[str]) -> None:
+        working[id(blk)] = dataclasses.replace(
+            blk,
+            lines=[
+                calkit.latex.SourceLine(blk.path, blk.lineno + i, text)
+                for i, text in enumerate(new_lines)
+            ],
+        )
+
     for para in doc.paragraphs:
         if para.bookmark is None or para.bookmark not in original.paragraphs:
             continue
@@ -3279,16 +3895,17 @@ def merge_docx(
             continue
         sent_tex = calkit.latex.from_word_text(sent)
         new_tex = calkit.latex.from_word_text(para.text)
-        if calkit.latex.already_applied(blk, sent_tex, new_tex):
+        current = working.get(id(blk), blk)
+        if calkit.latex.already_applied(current, sent_tex, new_tex):
             changes.append(
                 LatexDocxMergeChange(
                     path=blk.path, lineno=blk.lineno, status="already-applied"
                 )
             )
             continue
-        new_lines = calkit.latex.apply_edit(blk, sent_tex, new_tex)
+        new_lines = calkit.latex.apply_edit(current, sent_tex, new_tex)
         if new_lines == [
-            ln.text.rstrip() for ln in blk.lines if ln.text.strip()
+            ln.text.rstrip() for ln in current.lines if ln.text.strip()
         ]:
             changes.append(
                 LatexDocxMergeChange(
@@ -3306,15 +3923,226 @@ def merge_docx(
                 )
             )
             continue
-        edits.setdefault(blk.path, []).append(
-            (blk.lineno, len(blk.lines), new_lines)
-        )
+        update(blk, new_lines)
         changes.append(
             LatexDocxMergeChange(
                 path=blk.path, lineno=blk.lineno, status="applied"
             )
         )
         typer.echo(f"Applied edit at {loc}")
+    # Inline math edited in Word goes back through the LaTeX the converter
+    # reads it as, to the same piece of the paragraph's math in the source.
+    # An export from before that was kept has each lined up with the
+    # source's math by order instead.
+    m_omath = calkit.docx._tag(calkit.docx.M, "oMath")
+    # Lined up by order only for Word's import, which converts the math as
+    # this does, going by the export's record on this machine
+    older_word_export = False
+    if not original.kept_inline:
+        for folder in (
+            calkit.latex.LOCAL_DOCX_EXPORTS_DIR,
+            calkit.latex.DOCX_EXPORTS_DIR,
+        ):
+            for record_path in glob.glob(
+                os.path.join(folder, f"*-{original.id}.json")
+            ):
+                try:
+                    with open(record_path, encoding="utf-8") as f:
+                        exported = json.load(f)
+                except (OSError, ValueError):
+                    continue
+                older_word_export |= exported.get("engine") == "word"
+    with_math: list[
+        tuple[calkit.docx.Paragraph, list[tuple[int, str]] | None, list[Any]]
+    ] = [
+        (
+            para,
+            original.inline.get(para.bookmark or ""),
+            [c for c in para.element if c.tag == m_omath],
+        )
+        for para in doc.paragraphs
+        if para.element is not None
+        and (
+            para.bookmark in original.inline
+            or (older_word_export and para.bookmark in original.paragraphs)
+        )
+    ]
+    with_math = [w for w in with_math if w[2]]
+    all_math = [m for *_, math_els in with_math for m in math_els]
+    if all_math and calkit.docx.find_pandoc() is None:
+        warn(
+            "Pandoc isn't installed, so edits to inline math aren't "
+            "merged; run 'calkit install pandoc'"
+        )
+        with_math = []
+    converted_source: dict[int, list[str | None]] = {}
+    preamble = "\n".join(
+        ln.text
+        for ln in lines
+        if re.match(
+            r"\s*\\(newcommand|renewcommand|providecommand|"
+            r"DeclareMathOperator|def)\b",
+            ln.text,
+        )
+    )
+    math_back: Iterator[str | None] = iter(
+        calkit.docx.omml_to_latex(all_math) if with_math else []
+    )
+    for para, sent_maths, math_els in with_math:
+        math_now = [next(math_back) for _ in math_els]
+        assert para.bookmark is not None
+        parts = para.bookmark.split("_")
+        path, lineno = path_for_hash.get(parts[1], ""), int(parts[2])
+        if sent_maths is None:
+            sent = original.paragraphs.get(para.bookmark, "")
+            blk = calkit.latex.find_block(
+                blks, path, lineno, sent
+            ) or calkit.latex.find_block(blks, path, lineno, para.text)
+            if blk is None or blk.display:
+                continue
+            # The source's math as the converter reads it back, as the
+            # export would have kept it
+            if id(blk) not in converted_source:
+                texs = [t for _, t, _ in blk.inline_math]
+                converted_source[id(blk)] = (
+                    calkit.docx.omml_to_latex(
+                        [
+                            m
+                            for m in calkit.docx.latex_to_omml(
+                                [f"${t}$" for t in texs], preamble
+                            )
+                            if m is not None
+                        ]
+                    )
+                    if texs
+                    else []
+                )
+            source_back = converted_source[id(blk)]
+            matcher = difflib.SequenceMatcher(
+                a=[
+                    tuple(calkit.latex.math_tokens(t)) if t else None
+                    for t in source_back
+                ],
+                b=[
+                    tuple(calkit.latex.math_tokens(t)) if t else None
+                    for t in math_now
+                ],
+                autojunk=False,
+            )
+            lined_up: dict[int, int] = {}
+            for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+                if tag == "equal" or (tag == "replace" and i2 - i1 == j2 - j1):
+                    lined_up.update(zip(range(j1, j2), range(i1, i2)))
+            keep = [j for j in range(len(math_now)) if j in lined_up]
+            sent_maths = [
+                (lined_up[j], source_back[lined_up[j]] or "") for j in keep
+            ]
+            math_now = [math_now[j] for j in keep]
+            math_els = [math_els[j] for j in keep]
+        edited_maths = [
+            (k, sent_m, edited_m)
+            for (k, sent_m), edited_m in zip(sent_maths, math_now)
+            if edited_m is None
+            or calkit.latex.math_tokens(edited_m)
+            != calkit.latex.math_tokens(sent_m)
+        ]
+        if not edited_maths and len(math_els) == len(sent_maths):
+            continue
+        sent = original.paragraphs.get(para.bookmark, "")
+        blk = calkit.latex.find_block(
+            blks, path, lineno, sent
+        ) or calkit.latex.find_block(blks, path, lineno, para.text)
+        loc = f"{path}:{lineno}" if blk is None else f"{blk.path}:{blk.lineno}"
+        if blk is None or len(math_els) != len(sent_maths):
+            warn(
+                f"Inline math was added or removed at {loc}; apply it by hand"
+            )
+            changes.append(
+                LatexDocxMergeChange(
+                    path=path, lineno=lineno, status="unplaced"
+                )
+            )
+            continue
+        if any(
+            e.tag
+            in (
+                calkit.docx._tag(calkit.docx.W, "ins"),
+                calkit.docx._tag(calkit.docx.W, "del"),
+            )
+            for m in math_els
+            for e in m.iter()
+        ):
+            warn(f"Tracked change at {loc} not yet accepted or rejected")
+            changes.append(
+                LatexDocxMergeChange(
+                    path=blk.path, lineno=blk.lineno, status="pending"
+                )
+            )
+            continue
+        current = working.get(id(blk), blk)
+        src = "\n".join(ln.text for ln in current.lines)
+        # The source's inline math in order, not counting any in comments
+        math_spans = [
+            m.span(1) if m.group(1) is not None else m.span(2)
+            for m in calkit.latex._INLINE_MATH_RE.finditer(src)
+            if not re.search(
+                r"(?<!\\)%", src[src.rfind("\n", 0, m.start()) + 1 : m.start()]
+            )
+        ]
+        for k, sent_m, edited_m in edited_maths:
+            if edited_m is None or k >= len(math_spans):
+                warn(f"Can't place an inline math edit at {loc}")
+                changes.append(
+                    LatexDocxMergeChange(
+                        path=blk.path, lineno=blk.lineno, status="unplaced"
+                    )
+                )
+                continue
+            start, end = math_spans[k]
+            math_piece = calkit.latex.Block(
+                [calkit.latex.SourceLine(blk.path, blk.lineno, src[start:end])]
+            )
+            if calkit.latex.math_similarity(
+                math_piece, edited_m
+            ) > calkit.latex.math_similarity(math_piece, sent_m):
+                changes.append(
+                    LatexDocxMergeChange(
+                        path=blk.path,
+                        lineno=blk.lineno,
+                        status="already-applied",
+                    )
+                )
+                continue
+            edited_piece = calkit.latex.apply_math_edit(
+                math_piece, sent_m, edited_m
+            )
+            if edited_piece is None:
+                warn(
+                    f"Inline math edit at {loc} doesn't fit the source; "
+                    f"apply it by hand: {' '.join(edited_m.split())}"
+                )
+                changes.append(
+                    LatexDocxMergeChange(
+                        path=blk.path, lineno=blk.lineno, status="unplaced"
+                    )
+                )
+                continue
+            edited_text = "\n".join(edited_piece)
+            src = src[:start] + edited_text + src[end:]
+            # Later pieces moved by the change in length
+            shift = len(edited_text) - (end - start)
+            math_spans = [
+                (a + shift, b + shift) if a >= end else (a, b)
+                for a, b in math_spans
+            ]
+            update(blk, src.split("\n"))
+            current = working[id(blk)]
+            changes.append(
+                LatexDocxMergeChange(
+                    path=blk.path, lineno=blk.lineno, status="applied"
+                )
+            )
+            typer.echo(f"Applied inline math edit at {loc}")
     # Equations edited in Word go back through the LaTeX the converter
     # reads them as, applied to the source's own spelling; one that can't
     # be placed that way goes in as a comment on the equation
@@ -3332,7 +4160,6 @@ def merge_docx(
             n: (next(it) if m is not None else None, authors)
             for n, (m, authors) in found.items()
         }
-        working: dict[int, calkit.latex.Block] = {}
         for name, (eq_tex, pending) in now.items():
             sent_eq = original.equations[name]
             if eq_tex is not None and calkit.latex.math_tokens(
@@ -3406,27 +4233,22 @@ def merge_docx(
                     )
                 )
                 continue
-            working[id(blk)] = calkit.latex.Block(
-                [
-                    calkit.latex.SourceLine(blk.path, blk.lineno + i, text)
-                    for i, text in enumerate(new_lines)
-                ]
-            )
+            update(blk, new_lines)
             changes.append(
                 LatexDocxMergeChange(
                     path=blk.path, lineno=blk.lineno, status="applied"
                 )
             )
             typer.echo(f"Applied equation edit at {loc}")
-        for blk in blks:
-            if id(blk) in working:
-                edits.setdefault(blk.path, []).append(
-                    (
-                        blk.lineno,
-                        len(blk.lines),
-                        [ln.text for ln in working[id(blk)].lines],
-                    )
+    for blk in blks:
+        if id(blk) in working:
+            edits.setdefault(blk.path, []).append(
+                (
+                    blk.lineno,
+                    len(blk.lines),
+                    [ln.text for ln in working[id(blk)].lines],
                 )
+            )
     files = {
         p: Path(p).read_text(encoding="utf-8").split("\n")
         for p in {ln.path for ln in lines}