From cbee864a9e8a82b2c2f3ae3d445b67b2c4455b4b Mon Sep 17 00:00:00 2001
From: Samuel Huang <hi@sgh.ng>
Date: Sat, 28 Mar 2026 20:23:48 -0400
Subject: [PATCH 1/4] initial fix

---
 merge.xslt | 54 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 53 insertions(+), 1 deletion(-)

diff --git a/merge.xslt b/merge.xslt
index 79b3779..8e4daa6 100644
--- a/merge.xslt
+++ b/merge.xslt
@@ -23,6 +23,12 @@
     as="element(w:p)*"
     select="$doc-b//w:p[m:oMathPara]"
   />
+  <!-- Block math content as m:oMath, used when marker isn't isolated. -->
+  <xsl:variable
+    name="math-block-inline"
+    as="element(m:oMath)*"
+    select="$doc-b//w:p[m:oMathPara]/m:oMathPara/m:oMath"
+  />
   <!--
     Inline math is a <m:oMath> child of <w:p> (there can be several), that is
     not in m:oMathPara.
@@ -50,7 +56,7 @@
   <xsl:function name="local:is-block" as="xs:boolean">
     <xsl:param name="p" as="element(w:p)"/>
     <xsl:sequence
-      select="count($p//w:t) = 1 and matches($p//w:t, $marker-block)"
+      select="matches(string-join($p//w:t, ''), concat('^', $marker-block, '$'))"
     />
   </xsl:function>
 
@@ -107,6 +113,30 @@
     </xsl:analyze-string>
   </xsl:function>
 
+  <!--
+    Split w:t on block markers and replace marker segments with corresponding
+    m:oMath. This is a fallback for converters that merge neighboring content
+    and marker into one paragraph.
+  -->
+  <xsl:function name="local:process-t-block" as="element()*">
+    <xsl:param name="t" as="element(w:t)"/>
+    <xsl:param name="rPr" as="element(w:rPr)?"/>
+    <xsl:analyze-string select="string($t)" regex="{$marker-block}">
+      <xsl:matching-substring>
+        <xsl:variable name="marker" select="."/>
+        <xsl:copy-of
+          select="$math-block-inline[local:extract-marker-index($marker)]"
+        />
+      </xsl:matching-substring>
+      <xsl:non-matching-substring>
+        <w:r>
+          <xsl:copy-of select="$rPr"/>
+          <w:t><xsl:value-of select="."/></w:t>
+        </w:r>
+      </xsl:non-matching-substring>
+    </xsl:analyze-string>
+  </xsl:function>
+
   <!--
     Handle w:r elements that contain inline markers.
 
@@ -131,4 +161,26 @@
     </xsl:for-each>
   </xsl:template>
 
+  <!--
+    Fallback for block markers that appear inside a mixed-content paragraph.
+    We inject m:oMath at marker position to avoid leaving raw marker text.
+  -->
+  <xsl:template match="w:r[w:t[matches(., $marker-block)]]" priority="2">
+    <xsl:variable name="rPr" select="w:rPr"/>
+    <xsl:for-each select="*">
+      <xsl:choose>
+        <xsl:when test="self::w:rPr"/>
+        <xsl:when test="self::w:t">
+          <xsl:copy-of select="local:process-t-block(., $rPr)"/>
+        </xsl:when>
+        <xsl:otherwise>
+          <w:r>
+            <xsl:copy-of select="$rPr"/>
+            <xsl:copy-of select="."/>
+          </w:r>
+        </xsl:otherwise>
+      </xsl:choose>
+    </xsl:for-each>
+  </xsl:template>
+
 </xsl:stylesheet>

From c8b9070cf0ebc941f21d0bde08483fd57e5b11f4 Mon Sep 17 00:00:00 2001
From: Samuel Huang <hi@sgh.ng>
Date: Sat, 28 Mar 2026 21:03:55 -0400
Subject: [PATCH 2/4] consolidate marker hanlding

---
 merge.xslt | 91 +++++++++++++++++++-----------------------------------
 1 file changed, 31 insertions(+), 60 deletions(-)

diff --git a/merge.xslt b/merge.xslt
index 8e4daa6..15e25c5 100644
--- a/merge.xslt
+++ b/merge.xslt
@@ -23,7 +23,12 @@
     as="element(w:p)*"
     select="$doc-b//w:p[m:oMathPara]"
   />
-  <!-- Block math content as m:oMath, used when marker isn't isolated. -->
+  <!--
+    Block math as bare m:oMath (unwrapped from m:oMathPara). Used when a block
+    marker shares a paragraph with other content, e.g. pdf2docx merges nearby
+    headings and the marker into one w:p, so we can't replace the whole
+    paragraph and must inject the math inline instead.
+  -->
   <xsl:variable
     name="math-block-inline"
     as="element(m:oMath)*"
@@ -47,11 +52,14 @@
     need two distinct markers.
   -->
   <xsl:variable name="marker-block" select="'@@MATH:BLOCK:\d+@@'"/>
-  <xsl:variable name="marker-inline" select="'@@MATH:INLINE:\d+@@'"/>
+  <xsl:variable name="marker-any" select="'@@MATH:(?:BLOCK|INLINE):\d+@@'"/>
 
   <!--
-    Block math marker is the only <w:t> child of the only <w:r> child of <w:p>.
-    We capture and swap the whole <w:p>.
+    A paragraph is a block marker when its combined text is exclusively a block
+    marker. The old check required exactly one w:t node, which fails when
+    converters like pdf2docx merge the marker paragraph with surrounding
+    content (e.g. headings) into a single w:p, is-block correctly returns
+    false in that case, letting the run-level template handle the marker.
   -->
   <xsl:function name="local:is-block" as="xs:boolean">
     <xsl:param name="p" as="element(w:p)"/>
@@ -74,11 +82,21 @@
     </xsl:copy>
   </xsl:template>
 
-  <!-- Extract index (digits between : and @@) from marker. -->
+  <!-- Extract index (digits between last : and @@) from marker. -->
   <xsl:function name="local:extract-marker-index" as="xs:integer">
     <xsl:param name="marker" as="xs:string"/>
-    <xsl:variable name="index" select="replace($marker, '.*:(\d+)@@', '$1')"/>
-    <xsl:sequence select="xs:integer($index)"/>
+    <xsl:sequence select="xs:integer(replace($marker, '.*:(\d+)@@', '$1'))"/>
+  </xsl:function>
+
+  <!-- Look up the m:oMath for any marker string, block or inline. -->
+  <xsl:function name="local:lookup-math" as="element(m:oMath)?">
+    <xsl:param name="marker" as="xs:string"/>
+    <xsl:variable name="i" select="local:extract-marker-index($marker)"/>
+    <xsl:sequence select="
+      if (starts-with($marker, '@@MATH:BLOCK:'))
+      then $math-block-inline[$i]
+      else $math-inline[$i]
+    "/>
   </xsl:function>
 
   <!--
@@ -86,12 +104,12 @@
     paragraph from B.
   -->
   <xsl:template match="w:p[local:is-block(.)]">
-    <xsl:variable name="marker" select="string(.//w:t)"/>
+    <xsl:variable name="marker" select="string-join(.//w:t, '')"/>
     <xsl:copy-of select="$math-block[local:extract-marker-index($marker)]"/>
   </xsl:template>
 
   <!--
-    Split w:t on inline markers and return a sequence of elements:
+    Split w:t on markers and return a sequence of elements:
 
     - Marker segments replaced with the corresponding m:oMath
     - Non-marker segments wrapped in w:r elements, with rPr included
@@ -99,34 +117,9 @@
   <xsl:function name="local:process-t" as="element()*">
     <xsl:param name="t" as="element(w:t)"/>
     <xsl:param name="rPr" as="element(w:rPr)?"/>
-    <xsl:analyze-string select="string($t)" regex="{$marker-inline}">
-      <xsl:matching-substring>
-        <xsl:variable name="marker" select="."/>
-        <xsl:copy-of select="$math-inline[local:extract-marker-index($marker)]"/>
-      </xsl:matching-substring>
-      <xsl:non-matching-substring>
-        <w:r>
-          <xsl:copy-of select="$rPr"/>
-          <w:t><xsl:value-of select="."/></w:t>
-        </w:r>
-      </xsl:non-matching-substring>
-    </xsl:analyze-string>
-  </xsl:function>
-
-  <!--
-    Split w:t on block markers and replace marker segments with corresponding
-    m:oMath. This is a fallback for converters that merge neighboring content
-    and marker into one paragraph.
-  -->
-  <xsl:function name="local:process-t-block" as="element()*">
-    <xsl:param name="t" as="element(w:t)"/>
-    <xsl:param name="rPr" as="element(w:rPr)?"/>
-    <xsl:analyze-string select="string($t)" regex="{$marker-block}">
+    <xsl:analyze-string select="string($t)" regex="{$marker-any}">
       <xsl:matching-substring>
-        <xsl:variable name="marker" select="."/>
-        <xsl:copy-of
-          select="$math-block-inline[local:extract-marker-index($marker)]"
-        />
+        <xsl:copy-of select="local:lookup-math(.)"/>
       </xsl:matching-substring>
       <xsl:non-matching-substring>
         <w:r>
@@ -138,12 +131,12 @@
   </xsl:function>
 
   <!--
-    Handle w:r elements that contain inline markers.
+    Handle w:r elements that contain inline or non-isolated block markers.
 
     This'll create more runs than needed, which doesn't interfere with the
     functionality of Word, but helps keep the code simple.
   -->
-  <xsl:template match="w:r[w:t[matches(., $marker-inline)]]">
+  <xsl:template match="w:r[w:t[matches(., $marker-any)]]">
     <xsl:variable name="rPr" select="w:rPr"/>
     <xsl:for-each select="*">
       <xsl:choose>
@@ -161,26 +154,4 @@
     </xsl:for-each>
   </xsl:template>
 
-  <!--
-    Fallback for block markers that appear inside a mixed-content paragraph.
-    We inject m:oMath at marker position to avoid leaving raw marker text.
-  -->
-  <xsl:template match="w:r[w:t[matches(., $marker-block)]]" priority="2">
-    <xsl:variable name="rPr" select="w:rPr"/>
-    <xsl:for-each select="*">
-      <xsl:choose>
-        <xsl:when test="self::w:rPr"/>
-        <xsl:when test="self::w:t">
-          <xsl:copy-of select="local:process-t-block(., $rPr)"/>
-        </xsl:when>
-        <xsl:otherwise>
-          <w:r>
-            <xsl:copy-of select="$rPr"/>
-            <xsl:copy-of select="."/>
-          </w:r>
-        </xsl:otherwise>
-      </xsl:choose>
-    </xsl:for-each>
-  </xsl:template>
-
 </xsl:stylesheet>

From 2dfa062c7a9eb9ad0a8d96fbe98f98c731cdf7a4 Mon Sep 17 00:00:00 2001
From: Samuel Huang <hi@sgh.ng>
Date: Sat, 28 Mar 2026 21:06:52 -0400
Subject: [PATCH 3/4] improve comments about marker names

---
 merge.xslt | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/merge.xslt b/merge.xslt
index 15e25c5..dd2e895 100644
--- a/merge.xslt
+++ b/merge.xslt
@@ -47,9 +47,10 @@
   <!-- FIND MARKERS IN A -->
 
   <!--
-    Inline marker, when in its own paragraph, can look exactly like a block
-    marker, i.e. can't be distinguished by examining the ancestors. Hence we
-    need two distinct markers.
+    Markers encode their type (BLOCK/INLINE) because structure alone can't
+    distinguish them. An inline marker in its own paragraph looks identical
+    to a block marker. marker-block is used by is-block for the paragraph-level
+    fast path; marker-any drives run-level replacement via lookup-math.
   -->
   <xsl:variable name="marker-block" select="'@@MATH:BLOCK:\d+@@'"/>
   <xsl:variable name="marker-any" select="'@@MATH:(?:BLOCK|INLINE):\d+@@'"/>

From 5c52c1d77cece6b3a6046d05591a20db1f63001b Mon Sep 17 00:00:00 2001
From: Samuel Huang <hi@sgh.ng>
Date: Sat, 28 Mar 2026 21:12:03 -0400
Subject: [PATCH 4/4] eliminate math-block-inline list

---
 merge.xslt | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

diff --git a/merge.xslt b/merge.xslt
index dd2e895..9791a1d 100644
--- a/merge.xslt
+++ b/merge.xslt
@@ -17,27 +17,13 @@
 
   <!-- OBTAIN MATH ELEMENTS FROM B -->
 
-  <!-- Block math paragraphs contain m:oMathPara -->
+  <!-- Block math: paragraphs containing m:oMathPara -->
   <xsl:variable
     name="math-block"
     as="element(w:p)*"
     select="$doc-b//w:p[m:oMathPara]"
   />
-  <!--
-    Block math as bare m:oMath (unwrapped from m:oMathPara). Used when a block
-    marker shares a paragraph with other content, e.g. pdf2docx merges nearby
-    headings and the marker into one w:p, so we can't replace the whole
-    paragraph and must inject the math inline instead.
-  -->
-  <xsl:variable
-    name="math-block-inline"
-    as="element(m:oMath)*"
-    select="$doc-b//w:p[m:oMathPara]/m:oMathPara/m:oMath"
-  />
-  <!--
-    Inline math is a <m:oMath> child of <w:p> (there can be several), that is
-    not in m:oMathPara.
-  -->
+  <!-- Inline math: m:oMath children of w:p not wrapped in m:oMathPara -->
   <xsl:variable
     name="math-inline"
     as="element(m:oMath)*"
@@ -89,13 +75,17 @@
     <xsl:sequence select="xs:integer(replace($marker, '.*:(\d+)@@', '$1'))"/>
   </xsl:function>
 
-  <!-- Look up the m:oMath for any marker string, block or inline. -->
+  <!--
+    Look up the m:oMath for any marker. For block markers that ended up in a
+    mixed paragraph (e.g. pdf2docx merging headings into one w:p), we unwrap
+    the m:oMath from the block paragraph's m:oMathPara.
+  -->
   <xsl:function name="local:lookup-math" as="element(m:oMath)?">
     <xsl:param name="marker" as="xs:string"/>
     <xsl:variable name="i" select="local:extract-marker-index($marker)"/>
     <xsl:sequence select="
       if (starts-with($marker, '@@MATH:BLOCK:'))
-      then $math-block-inline[$i]
+      then $math-block[$i]/m:oMathPara/m:oMath
       else $math-inline[$i]
     "/>
   </xsl:function>